c5e5aafbd355d40c9a6098a76e091f0ce9686827f74aacd3a679fc72967ac606

Auto-Photoshop-StableDiffusion-Plugin/install.py

@@ -0,0 +1,53 @@
+import os
+from pathlib import Path
+from launch import git, run
+import launch
+import sys
+
+# launch.run(f'git pull', f"updating auto-photoshop plugin",
+#         f"Couldn't update auto-photoshop plugin")
+
+
+REPO_LOCATION = Path(__file__).parent
+# auto_update = os.environ.get("AUTO_UPDATE", "True").lower() in {"true", "yes"}
+auto_update = True
+extension_branch = "master"
+# extension_branch = "horde_native"
+# extension_branch = "auto_extension_ccx_1_1_7"
+
+if auto_update:
+    print("[Auto-Photoshop-SD] Attempting auto-update...")
+
+    try:
+
+        checkout_result = run(f'"{git}" -C "{REPO_LOCATION}" checkout {extension_branch}', "[Auto-Photoshop-SD] switch branch to extension branch.")
+        print("checkout_result:",checkout_result)
+
+        branch_result = run(f'"{git}" -C "{REPO_LOCATION}" branch', "[Auto-Photoshop-SD] Current Branch.")
+        print("branch_result:",branch_result)
+        
+        fetch_result = run(f'"{git}" -C "{REPO_LOCATION}" fetch', "[Auto-Photoshop-SD] Fetch upstream.")
+        print("fetch_result:",fetch_result)
+
+        pull_result = run(f'"{git}" -C "{REPO_LOCATION}" pull', "[Auto-Photoshop-SD] Pull upstream.")
+        print("pull_result:",pull_result)
+
+    except Exception as e:
+        print("[Auto-Photoshop-SD] Auto-update failed:")
+        print(e)
+        print("[Auto-Photoshop-SD] Ensure git was used to install extension.")
+
+
+# print("Auto-Photoshop-SD plugin is installing")
+
+package_name = 'duckduckgo_search'
+package_version= '3.7.1'
+if not launch.is_installed(package_name):
+    launch.run_pip(f"install {package_name}=={package_version}", "requirements for Auto-Photoshop Image Search")
+else:# it's installed but we need to check for update
+    import pkg_resources
+
+    version = pkg_resources.get_distribution(package_name).version
+    if(version != package_version):
+        print(f'{package_name} version: {version} will update to version: {package_version}')
+        launch.run_pip(f"install {package_name}=={package_version}", "update requirements for Auto-Photoshop Image Search")

Auto-Photoshop-StableDiffusion-Plugin/manifest.json

@@ -0,0 +1,141 @@
+{
+  "id": "auto.photoshop.stable.diffusion.plugin",
+  "name": "Auto Photoshop Stable Diffusion Plugin",
+  "version": "1.1.0",
+  "host": [
+    {
+      "app": "PS",
+      "minVersion": "24.0.0"
+    }
+  ],
+  "main": "index.html",
+  "manifestVersion": 5,
+  "requiredPermissions": {
+    "network": {
+      "domains": "all"
+    },
+    "launchProcess": {
+      "schemes": [
+        "http",
+        "https",
+        "mailto"
+      ],
+      "extensions": [
+        ".png",
+        ".jpg",
+        ".pdf",
+        ""
+      ]
+    },
+    "clipboard": "readAndWrite",
+    "localFileSystem": "request",
+    "ipc": {
+      "enablePluginCommunication": true
+    }
+  },
+  "entrypoints": [
+    {
+      "type": "panel",
+      "id": "vanilla",
+      "label": {
+        "default": "Auto-Photoshop-SD",
+        "en-US": "Auto-Photoshop-SD",
+        "es-ES": "Auto-Photoshop-SD"
+      },
+      "minimumSize": {
+        "width": 400,
+        "height": 800
+      },
+      "maximumSize": {
+        "width": 1200,
+        "height": 10000
+      },
+      "preferredDockedSize": {
+        "width": 150,
+        "height": 800
+      },
+      "preferredFloatingSize": {
+        "width": 300,
+        "height": 800
+      },
+      "commands": [
+        {
+          "id": "show_alert",
+          "label": {
+            "default": "Show Alert",
+            "en-US": "Show Alert (US)",
+            "es-ES": "Show Alert (ES)"
+          }
+        }
+      ],
+      "icons": [
+        {
+          "width": 32,
+          "height": 32,
+          "path": "icon/icon_D.png",
+          "scale": [
+            1,
+            2
+          ],
+          "theme": [
+            "dark",
+            "darkest"
+          ],
+          "species": [
+            "generic"
+          ]
+        },
+        {
+          "width": 32,
+          "height": 32,
+          "path": "icon/icon_N.png",
+          "scale": [
+            1,
+            2
+          ],
+          "theme": [
+            "lightest",
+            "light"
+          ],
+          "species": [
+            "generic"
+          ]
+        }
+      ]
+    }
+  ],
+  "icons": [
+    {
+      "width": 32,
+      "height": 32,
+      "path": "icon/icon_D.png",
+      "scale": [
+        1,
+        2
+      ],
+      "theme": [
+        "dark",
+        "darkest"
+      ],
+      "species": [
+        "generic"
+      ]
+    },
+    {
+      "width": 32,
+      "height": 32,
+      "path": "icon/icon_N.png",
+      "scale": [
+        1,
+        2
+      ],
+      "theme": [
+        "lightest",
+        "light"
+      ],
+      "species": [
+        "generic"
+      ]
+    }
+  ]
+}

Auto-Photoshop-StableDiffusion-Plugin/outpaint.js

@@ -0,0 +1,518 @@
+const app = window.require('photoshop').app
+
+const batchPlay = require('photoshop').action.batchPlay
+const psapi = require('./psapi')
+
+async function moveLayersToGroup(group_id) {
+    const activeLayers = await app.activeDocument.activeLayers
+    const layerIDs = activeLayers.map((layer) => layer.id)
+    const { executeAsModal } = require('photoshop').core
+    await executeAsModal(async () => {
+        await psapi.moveToGroupCommand(group_id, layerIDs)
+    })
+}
+
+async function createSnapshot() {
+    const { executeAsModal } = require('photoshop').core
+    //get all layers,
+    //duplicate the layers
+    //create a group
+    //move the duplicate layers to the group
+    let snapshotLayer, snapshotGroup
+    try {
+        const selectionInfo = await psapi.getSelectionInfoExe()
+        await psapi.unSelectMarqueeExe()
+
+        //get all layers
+        const allLayers = await app.activeDocument.layers
+
+        // const allLayerNames = allLayers.map(
+        //     layer => `${layer.name} (${layer.opacity} %)`
+        //   )
+        // for (layer of allLayerNames){
+        //     console.log(layer)
+        // }
+        //duplicate the layers
+        let duplicatedLayers = []
+
+        // const group_id = await createGroup()
+        const groupLayer = await psapi.createEmptyGroup()
+
+        console.log('createSnapshot(), group_id:', groupLayer.id)
+        // let bHasBackground = false
+        let indexOffset = 0
+
+        const result1 = await executeAsModal(async () => {
+            for (layer of allLayers) {
+                if (layer.id == 1) {
+                    //skip the background layer
+                    // bHasBackground = true
+                    indexOffset = 1
+                    continue
+                }
+                if (layer.visible) {
+                    const copyLayer = await layer.duplicate()
+                    duplicatedLayers.push(copyLayer)
+                }
+            }
+
+            const layerIDs = duplicatedLayers.map((layer) => layer.id)
+            console.log('createSnapshot, layerIDs:', layerIDs)
+
+            //select the layer since layerIDs don't seem to have an affect on moveToGroupCommand(), don't know why!!!!
+            psapi.selectLayers(duplicatedLayers)
+            let group_index = await psapi.getLayerIndex(groupLayer.id)
+
+            await psapi.moveToGroupCommand(group_index - indexOffset, layerIDs)
+
+            await psapi.collapseGroup(duplicatedLayers[0])
+            snapshotLayer = app.activeDocument.activeLayers[0]
+            await psapi.createSolidLayer(255, 255, 255)
+            const whiteSolidLayer = app.activeDocument.activeLayers[0]
+            await snapshotLayer.moveAbove(whiteSolidLayer)
+            snapshotGroup = await psapi.createEmptyGroup()
+            let snapshot_group_index = await psapi.getLayerIndex(
+                snapshotGroup.id
+            )
+
+            await psapi.selectLayers([snapshotLayer, whiteSolidLayer])
+            await psapi.moveToGroupCommand(
+                snapshot_group_index - indexOffset,
+                []
+            )
+            await psapi.selectLayers([snapshotGroup])
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            await psapi.createMaskExe()
+            //   await psapi.selectLayerChannelCommand()
+            //   await psapi.createSolidLayer(0, 0, 0)
+        })
+
+        return [snapshotLayer, snapshotGroup]
+    } catch (e) {
+        console.warn('createSnapshot Error:', e)
+    }
+}
+
+function executeCommand(batchPlayCommandFunc) {
+    const { executeAsModal } = require('photoshop').core
+    try {
+        executeAsModal(async () => {
+            await batchPlayCommandFunc()
+        })
+    } catch (e) {
+        console.warn('executeCommand error:', e)
+    }
+}
+
+async function snapAndFillExe(session_id) {
+    //create a snapshot of canvas
+    //select opaque pixel and create black fill layer
+    //create a snapshot of mask
+    //set initial image
+    //set mask image
+
+    try {
+        let snapAndFillLayers = []
+        await executeAsModal(async (context) => {
+            const history_id = await context.hostControl.suspendHistory({
+                documentID: app.activeDocument.id, //TODO: change this to the session document id
+                name: 'Img2Img layers',
+            })
+            const selectionInfo = await psapi.getSelectionInfoExe()
+            // await psapi.unSelectMarqueeExe()
+
+            //create a snapshot of canvas
+            // let [snapshotLayer,snapshotGroup] =  await createSnapshot()
+            await psapi.snapshot_layerExe()
+            const snapshotLayer = await app.activeDocument.activeLayers[0]
+            const snapshotGroup = await psapi.createEmptyGroup()
+            snapshotLayer.name = 'Init Image Snapshot -- temporary'
+            snapshotGroup.name = 'Init Image Group -- temporary'
+
+            // snapshotGroup.name = `${snapshotGroup.name}_init_image`
+            await psapi.createSolidLayer(255, 255, 255)
+            const whiteSolidLayer = await app.activeDocument.activeLayers[0]
+            whiteSolidLayer.name = 'Background Color -- temporary'
+            snapshotLayer.moveAbove(whiteSolidLayer)
+            console.log('[snapshotLayer,snapshotGroup]:', [
+                snapshotLayer,
+                snapshotGroup,
+            ])
+
+            //create a snapshot of mask
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            // let [snapshotMaskLayer,snapshotMaskGroup] = await createSnapshot()
+
+            await psapi.selectLayers([snapshotGroup])
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            await psapi.createClippingMaskExe()
+
+            await psapi.selectLayers([snapshotGroup])
+
+            snapAndFillLayers = [snapshotLayer, snapshotGroup, whiteSolidLayer]
+
+            // g_init_image_related_layers['init_image_group'] = snapshotGroup
+            // g_init_image_related_layers['init_image_layer'] = snapshotLayer
+            // g_init_image_related_layers['solid_white'] = whiteSolidLayer
+
+            const image_info = await psapi.silentSetInitImage(
+                snapshotGroup,
+                session_id
+            )
+            const image_name = image_info['name']
+            const path = `./server/python_server/init_images/${image_name}`
+
+            g_viewer_manager.initializeInitImage(
+                snapshotGroup,
+                snapshotLayer,
+                whiteSolidLayer,
+                path
+            ) //this will be called once a session and will add the first init image to th viewer manager
+
+            for (layer of snapAndFillLayers) {
+                layer.visible = false
+            }
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            const layer_util = require('./utility/layer')
+            await layer_util.collapseFolderExe([snapshotGroup], false)
+            await context.hostControl.resumeHistory(history_id)
+        })
+        console.log('snapAndFillLayers: ', snapAndFillLayers)
+        return snapAndFillLayers
+    } catch (e) {
+        console.error(`snapAndFill error: ${e}`)
+    }
+    return []
+}
+
+async function addClippingMaskToLayer(layer, selectionInfo) {
+    await psapi.selectLayers([layer]) //select the layer
+    await psapi.reSelectMarqueeExe(selectionInfo) //reselect the selection
+    await psapi.createClippingMaskExe() //this will create an cliping mask and select the mask of the layer
+    await psapi.selectLayers([layer]) //reselect the layer instead of the mask
+    await psapi.reSelectMarqueeExe(selectionInfo) //reselect the selection
+
+    ////test addClippingMaskToLayer
+    // await executeAsModal(
+    //   async ()=>{
+    //   await outpaint.addClippingMaskToLayer(await app.activeDocument.activeLayers[0],await psapi.getSelectionInfoExe()
+    //   )})
+}
+
+async function outpaintExe(session_id) {
+    //create a snapshot of canvas
+    //select opaque pixel and create black fill layer
+    //create a snapshot of mask
+    //set initial image
+    //set mask image
+
+    try {
+        let outpaintLayers = []
+        await executeAsModal(async (context) => {
+            const history_id = await context.hostControl.suspendHistory({
+                documentID: app.activeDocument.id, //TODO: change this to the session document id
+                name: 'Outpaint Mask Related layers',
+            })
+            const selectionInfo = await psapi.getSelectionInfoExe()
+            // await psapi.unSelectMarqueeExe()
+
+            //create a snapshot of canvas
+            // let [snapshotLayer,snapshotGroup] =  await createSnapshot()
+            await psapi.snapshot_layerExe()
+            const snapshotLayer = await app.activeDocument.activeLayers[0]
+            snapshotLayer.name = 'Init Image Snapshot -- temporary'
+            const snapshotGroup = await psapi.createEmptyGroup()
+            // snapshotGroup.name = `${snapshotGroup.name}_init_image`
+            snapshotGroup.name = 'Init Image Group -- temporary'
+            await psapi.createSolidLayer(255, 255, 255) //solid white inside the Init Image Group
+            const whiteSolidLayer = await app.activeDocument.activeLayers[0]
+            whiteSolidLayer.name = 'Background Color -- temporary'
+            snapshotLayer.moveAbove(whiteSolidLayer) //move the snapshot layer to be the first layer in "Init Image Group"
+            console.log('[snapshotLayer,snapshotGroup]:', [
+                snapshotLayer,
+                snapshotGroup,
+            ])
+
+            //select opaque pixel and create black fill layer
+            await psapi.selectLayers([snapshotLayer])
+            await psapi.selectLayerChannelCommand()
+            const snapshotMaskGroup = await psapi.createEmptyGroup()
+
+            await psapi.createSolidLayer(0, 0, 0)
+            let solid_black_layer = app.activeDocument.activeLayers[0]
+            //create a snapshot of mask
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            // let [snapshotMaskLayer,snapshotMaskGroup] = await createSnapshot()
+            await psapi.snapshot_layerExe()
+            const snapshotMaskLayer = await app.activeDocument.activeLayers[0]
+            snapshotMaskLayer.name = 'Mask -- Paint White to Mask -- temporary'
+            // const snapshotMaskGroup = await psapi.createEmptyGroup()
+
+            // snapshotMaskGroup.name = `${snapshotMaskGroup.name}_mask`
+            snapshotMaskGroup.name = 'Mask Group -- temporary'
+            snapshotMaskLayer.moveBelow(solid_black_layer)
+            await snapshotMaskGroup.moveAbove(snapshotGroup)
+            await solid_black_layer.delete() //
+
+            await addClippingMaskToLayer(snapshotGroup, selectionInfo)
+
+            const mask_info = await psapi.silentSetInitImageMask(
+                snapshotMaskGroup,
+                session_id
+            )
+            snapshotMaskGroup.visible = false
+
+            const image_info = await psapi.silentSetInitImage(
+                snapshotGroup,
+                session_id
+            )
+            snapshotGroup.visible = false
+
+            const init_image_name = image_info['name']
+            const init_path = `./server/python_server/init_images/${init_image_name}`
+
+            await psapi.reSelectMarqueeExe(selectionInfo)
+
+            await addClippingMaskToLayer(snapshotMaskGroup, selectionInfo)
+
+            await psapi.reSelectMarqueeExe(selectionInfo)
+
+            // await psapi.silentSetInitImageMask(snapshotMaskGroup,session_id)
+
+            const mask_name = mask_info['name']
+            const mask_path = `./server/python_server/init_images/${mask_name}`
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            //set initial image
+            //set mask image
+            outpaintLayers = [
+                snapshotMaskGroup,
+                snapshotMaskLayer,
+                snapshotLayer,
+                snapshotGroup,
+                whiteSolidLayer,
+            ]
+            // g_mask_related_layers['mask_group'] = snapshotMaskGroup
+            // g_mask_related_layers['white_mark'] = snapshotMaskLayer
+            // // g_mask_related_layers['solid_black'] = blackSolidLayer
+            g_viewer_manager.initializeMask(
+                snapshotMaskGroup,
+                snapshotMaskLayer,
+                null,
+                mask_path,
+                mask_info['base64']
+            )
+            // g_init_image_related_layers['init_image_group'] = snapshotGroup
+            // g_init_image_related_layers['init_image_layer'] = snapshotLayer
+            // g_init_image_related_layers['solid_white'] = whiteSolidLayer
+            g_viewer_manager.initializeInitImage(
+                snapshotGroup,
+                snapshotLayer,
+                whiteSolidLayer,
+                init_path
+            ) //this will be called once a session and will add the first init image to th viewer manager
+
+            for (layer of outpaintLayers) {
+                layer.visible = false
+            }
+
+            //collapse the folders
+            const layer_util = require('./utility/layer')
+            await layer_util.collapseFolderExe(
+                [snapshotGroup, snapshotMaskGroup],
+                false
+            )
+            await context.hostControl.resumeHistory(history_id)
+        })
+        console.log('outpaintLayers 2: ', outpaintLayers)
+        return outpaintLayers
+    } catch (e) {
+        console.error(`outpaintExe error: ${e}`)
+    }
+    return []
+}
+
+async function inpaintFasterExe(session_id) {
+    //
+    //create a snapshot of canvas
+    //select opaque pixel and create black fill layer
+    //create a snapshot of mask
+    //set initial image
+    //set mask image
+    try {
+        let inpaintLayers = []
+        await executeAsModal(async (context) => {
+            const history_id = await context.hostControl.suspendHistory({
+                documentID: app.activeDocument.id,
+                name: 'Inpaint Mask Related layers',
+            })
+            const original_white_mark_layer = await app.activeDocument
+                .activeLayers[0]
+            original_white_mark_layer.visible = false
+
+            const selectionInfo = await psapi.getSelectionInfoExe()
+
+            //duplicate the current active layer and use it as the white mark layer
+            const white_mark_layer =
+                await app.activeDocument.activeLayers[0].duplicate()
+            white_mark_layer.visible = true
+            const mask_layer_opacity = await white_mark_layer.opacity
+            white_mark_layer.opacity = 100 //make sure the opacity is full
+            await psapi.selectLayers([white_mark_layer])
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            await psapi.createClippingMaskExe()
+            await psapi.reSelectMarqueeExe(selectionInfo)
+
+            white_mark_layer.visible = false
+            white_mark_layer.name = 'Mask -- Paint White to Mask -- temporary'
+            // white_mark_layer.visible = true
+
+            //create a snapshot of canvas
+
+            // let [snapshotLayer,snapshotGroup] =  await createSnapshot()
+            // await psapi.snapshot_layer()
+            await psapi.unselectActiveLayersExe() //invisible layer will cause problem with merging "command is not available" type of error
+            // await psapi.mergeVisibleExe()
+            await psapi.snapshot_layerExe()
+
+            const snapshotLayer = await app.activeDocument.activeLayers[0]
+            snapshotLayer.name = 'Init Image Snapshot -- temporary'
+            const snapshotGroup = await psapi.createEmptyGroup()
+            snapshotGroup.name = 'Init Image Group -- temporary'
+            await psapi.createSolidLayer(255, 255, 255)
+            const whiteSolidLayer = await app.activeDocument.activeLayers[0]
+            whiteSolidLayer.name = 'Background Color -- temporary'
+            await snapshotLayer.moveAbove(whiteSolidLayer)
+
+            await psapi.selectLayers([snapshotGroup])
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            await psapi.createClippingMaskExe()
+            await psapi.reSelectMarqueeExe(selectionInfo)
+
+            const maskGroup = await psapi.createEmptyGroup()
+            // maskGroup.name = `${maskGroup.name}_mask`
+
+            maskGroup.name = 'Mask Group -- temporary'
+
+            await psapi.createSolidLayer(0, 0, 0)
+            const blackSolidLayer = await app.activeDocument.activeLayers[0]
+            blackSolidLayer.name = "Don't Edit -- temporary"
+            // snapshotLayer.moveAbove(blackSolidLayer)
+            white_mark_layer.moveAbove(blackSolidLayer)
+            white_mark_layer.visible = true
+            await psapi.reSelectMarqueeExe(selectionInfo)
+
+            console.log('[snapshotLayer,maskGroup]:', [
+                snapshotLayer,
+                maskGroup,
+            ])
+            // //select opaque pixel and create black fill layer
+            // await psapi.selectLayers([snapshotLayer])
+            // await psapi.selectLayerChannelCommand()
+            // const snapshotMaskGroup = await psapi.createEmptyGroup()
+
+            // await psapi.createSolidLayer(0, 0, 0)
+            // let solid_black_layer  = app.activeDocument.activeLayers[0]
+            // //create a snapshot of mask
+            // await psapi.reSelectMarqueeExe(selectionInfo)
+            // // let [snapshotMaskLayer,snapshotMaskGroup] = await createSnapshot()
+            // await psapi.snapshot_layer()
+            // const snapshotMaskLayer = await app.activeDocument.activeLayers[0]
+            // // const snapshotMaskGroup = await psapi.createEmptyGroup()
+
+            // snapshotMaskGroup.name = `${snapshotMaskGroup.name}_mask`
+            // snapshotMaskLayer.moveBelow(solid_black_layer)
+            // await snapshotMaskGroup.moveAbove(snapshotGroup)
+            // solid_black_layer.delete()
+
+            await psapi.selectLayers([maskGroup])
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            await psapi.createClippingMaskExe()
+            await psapi.reSelectMarqueeExe(selectionInfo)
+
+            // await psapi.selectLayers([snapshotGroup])
+
+            await psapi.selectLayers([maskGroup])
+            // await psapi.silentSetInitImageMask(maskGroup,session_id)
+            const mask_info = await psapi.silentSetInitImageMask(
+                maskGroup,
+                session_id
+            )
+            maskGroup.visible = false
+            //hide the mask so you can take screenshot of the init image
+            const mask_name = mask_info['name']
+            const mask_path = `./server/python_server/init_images/${mask_name}`
+
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            await psapi.selectLayers([snapshotGroup])
+
+            const image_info = await psapi.silentSetInitImage(
+                snapshotGroup,
+                session_id
+            )
+            const image_name = image_info['name']
+            const path = `./server/python_server/init_images/${image_name}`
+
+            await psapi.reSelectMarqueeExe(selectionInfo)
+            // await psapi.selectLayers([snapshotMaskGroup])
+            // await psapi.setInitImageMask(snapshotMaskGroup)
+            // //set initial image
+            // //set mask image
+
+            await psapi.selectLayers([maskGroup])
+            inpaintLayers = [
+                maskGroup,
+                white_mark_layer,
+                blackSolidLayer,
+                snapshotGroup,
+                snapshotLayer,
+                whiteSolidLayer,
+            ]
+            // g_mask_related_layers['mask_group'] = maskGroup
+            // g_mask_related_layers['white_mark'] = white_mark_layer
+            // g_mask_related_layers['solid_black'] = blackSolidLayer
+            g_viewer_manager.initializeMask(
+                maskGroup,
+                white_mark_layer,
+                blackSolidLayer,
+                mask_path,
+                mask_info['bases64']
+            )
+            // g_init_image_related_layers['init_image_group'] = snapshotGroup
+            // g_init_image_related_layers['init_image_layer'] = snapshotLayer
+            // g_init_image_related_layers['solid_white'] = whiteSolidLayer
+            g_viewer_manager.initializeInitImage(
+                snapshotGroup,
+                snapshotLayer,
+                whiteSolidLayer,
+                path
+            ) //this will be called once a session and will add the first init image to th viewer manager
+            for (layer of inpaintLayers) {
+                layer.visible = false
+            }
+            const layer_util = require('./utility/layer')
+
+            await layer_util.collapseFolderExe(
+                [snapshotGroup, maskGroup],
+                false
+            )
+            white_mark_layer.opacity = mask_layer_opacity // restore the opacity
+            // original_white_mark_layer.visible = true// leave it off so we can toggle using the viewer manager
+            await context.hostControl.resumeHistory(history_id)
+        })
+        return inpaintLayers
+    } catch (e) {
+        console.warn('inpaintFasterExe error:', e)
+    }
+    return []
+}
+module.exports = {
+    createSnapshot,
+
+    moveLayersToGroup,
+    executeCommand,
+    outpaintExe,
+    // outpaintFasterExe,
+    inpaintFasterExe,
+    snapAndFillExe,
+    addClippingMaskToLayer,
+}

Auto-Photoshop-StableDiffusion-Plugin/package.json

@@ -0,0 +1,55 @@
+{
+    "name": "uxp-template-default-starter",
+    "version": "1.0.0",
+    "description": "Default template for creating Adobe UXP based photoshop plugin.",
+    "author": "Adobe Inc",
+    "license": "Apache-2.0",
+    "dependencies": {
+        "@types/react": "^18.2.6",
+        "@types/react-dom": "^18.2.4",
+        "fastify": "^4.10.2",
+        "jimp": "^0.16.2",
+        "md5": "^2.3.0",
+        "mobx": "^6.9.0",
+        "mobx-react": "^7.6.0",
+        "react": "^18.2.0",
+        "react-dom": "^18.2.0"
+    },
+    "main": "index.js",
+    "directories": {
+        "test": "test"
+    },
+    "devDependencies": {
+        "@babel/core": "^7.21.8",
+        "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+        "@babel/plugin-syntax-class-properties": "^7.12.13",
+        "@babel/plugin-transform-react-jsx": "^7.21.5",
+        "babel-loader": "^9.1.2",
+        "clean-webpack-plugin": "^4.0.0",
+        "copy-webpack-plugin": "^11.0.0",
+        "css-loader": "^6.7.3",
+        "file-loader": "^6.2.0",
+        "nodemon": "^2.0.22",
+        "prettier": "2.8.3",
+        "style-loader": "^3.3.2",
+        "terser-webpack-plugin": "^3.0.8",
+        "ts-loader": "^9.4.2",
+        "typescript": "^5.0.4",
+        "webpack": "^5.82.1",
+        "webpack-cli": "^5.1.1"
+    },
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "build": "cd ultimate_sd_upscaler && npx webpack --config webpack.config.js",
+        "watch": "cd ultimate_sd_upscaler && npx webpack --config webpack.config.js --watch"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/AbdullahAlfaraj/Auto-Photoshop-StableDiffusion-Plugin.git"
+    },
+    "keywords": [],
+    "bugs": {
+        "url": "https://github.com/AbdullahAlfaraj/Auto-Photoshop-StableDiffusion-Plugin/issues"
+    },
+    "homepage": "https://github.com/AbdullahAlfaraj/Auto-Photoshop-StableDiffusion-Plugin#readme"
+}

Auto-Photoshop-StableDiffusion-Plugin/psapi.js

@@ -0,0 +1,1598 @@
+const app = window.require('photoshop').app
+const batchPlay = require('photoshop').action.batchPlay
+const { executeAsModal } = require('photoshop').core
+// const export_png = require('./export_png')
+
+// const { layerToSelection } = require('./helper')
+
+const storage = require('uxp').storage
+const fs = storage.localFileSystem
+
+async function createSolidLayer(r, g, b) {
+    console.warn('this function is deprecated')
+    await executeAsModal(async () => {
+        const result = await batchPlay(
+            [
+                {
+                    _obj: 'make',
+                    _target: [
+                        {
+                            _ref: 'contentLayer',
+                        },
+                    ],
+                    using: {
+                        _obj: 'contentLayer',
+                        type: {
+                            _obj: 'solidColorLayer',
+                            color: {
+                                _obj: 'RGBColor',
+                                red: r,
+                                grain: g,
+                                blue: b,
+                            },
+                        },
+                    },
+                    _options: {
+                        dialogOptions: 'dontDisplay',
+                    },
+                },
+            ],
+            {
+                synchronousExecution: true,
+                modalBehavior: 'execute',
+            }
+        )
+    })
+}
+
+async function makeGroupCommand() {
+    const result = await batchPlay(
+        [
+            {
+                _obj: 'make',
+                _target: [
+                    {
+                        _ref: 'layerSection',
+                    },
+                ],
+                layerSectionStart: 405,
+                layerSectionEnd: 406,
+                name: 'Group 16',
+                _options: {
+                    dialogOptions: 'dontDisplay',
+                },
+            },
+        ],
+        {
+            synchronousExecution: true,
+            modalBehavior: 'execute',
+        }
+    )
+
+    console.log('makeGroupCommand: ', result)
+
+    return result
+}
+async function createEmptyGroup(name = 'New Group') {
+    let groupLayer
+    await executeAsModal(async () => {
+        await makeGroupCommand()
+        groupLayer = app.activeDocument.activeLayers[0]
+        groupLayer.name = name
+    })
+    console.log('groupLayer:', groupLayer)
+    return groupLayer
+}
+
+async function moveToGroupCommand(to_index, layerIDs) {
+    const batchPlay = require('photoshop').action.batchPlay
+    console.log('to_index:', to_index)
+    console.log('layerIDs:', layerIDs)
+
+    const result = await batchPlay(
+        [
+            {
+                _obj: 'move',
+                _target: [
+                    {
+                        _ref: 'layer',
+                        _enum: 'ordinal',
+                        _value: 'targetEnum',
+                    },
+                ],
+                to: {
+                    _ref: 'layer',
+                    _index: to_index,
+                },
+                adjustment: false,
+                version: 5,
+                layerID: layerIDs,
+                _options: {
+                    dialogOptions: 'dontDisplay',
+                },
+            },
+        ],
+        {
+            synchronousExecution: true,
+            modalBehavior: 'execute',
+        }
+    )
+}
+function MoveToGroupExe(toIndex, layerIDs) {
+    try {
+        executeAsModal(async () => {
+            await moveToGroupCommand(toIndex, layerIDs)
+        })
+    } catch (e) {
+        console.warn('executeCommand error:', e)
+    }
+}
+
+async function getIndexCommand(layer_id) {
+    const idx = batchPlay(
+        [
+            {
+                _obj: 'get',
+                _target: [
+                    {
+                        _property: 'itemIndex',
+                    },
+                    {
+                        _ref: 'layer',
+                        // _name: 'myGroup'
+                        _id: layer_id,
+                    },
+                ],
+                _options: {
+                    dialogOptions: 'dontDisplay',
+                },
+            },
+        ],
+        { synchronousExecution: true }
+    )[0]['itemIndex']
+    console.log('index:', idx)
+    return idx
+}
+
+async function getLayerIndex(layer_id) {
+    const { executeAsModal } = require('photoshop').core
+    try {
+        let index
+        await executeAsModal(async () => {
+            index = await getIndexCommand(layer_id)
+            console.log('getIndex: ', index)
+        })
+        return index
+    } catch (e) {
+        console.warn('getIndex error:', e)
+    }
+}
+
+async function unselectActiveLayers() {
+    const layers = await app.activeDocument.activeLayers
+    for (layer of layers) {
+        layer.selected = false
+    }
+}
+async function unselectActiveLayersExe() {
+    await executeAsModal(async () => {
+        await unselectActiveLayers()
+    })
+}
+async function selectLayers(layers) {
+    await unselectActiveLayers()
+    for (layer of layers) {
+        try {
+            if (layer) {
+                const is_visible = layer.visible // don't change the visibility when selecting the layer
+                layer.selected = true
+                layer.visible = is_visible
+            }
+        } catch (e) {
+            console.warn(e)
+        }
+    }
+}
+
+async function setVisibleExe(layer, is_visible) {
+    try {
+        await executeAsModal(async () => {
+            layer.visible = is_visible
+        })
+    } catch (e) {
+        console.warn(e)
+    }
+}
+async function selectLayersExe(layers) {
+    await executeAsModal(async () => {
+        await selectLayers(layers)
+    })
+}
+async function selectGroup(layer) {
+    await unselectActiveLayers()
+    layer.parent.selected = true
+}
+async function collapseGroup(layer) {
+    await selectGroup(layer)
+    await app.activeDocument.activeLayers[0].merge()
+}
+
+async function createMaskCommand() {
+    const batchPlay = require('photoshop').action.batchPlay
+
+    const result = await batchPlay(
+        [
+            {
+                _obj: 'make',
+                new: {
+                    _class: 'channel',
+                },
+                at: {
+                    _ref: 'channel',
+                    _enum: 'channel',
+                    _value: 'mask',
+                },
+                using: {
+                    _enum: 'userMaskEnabled',
+                    _value: 'revealSelection',
+                },
+                _options: {
+                    dialogOptions: 'dontDisplay',
+                },
+            },
+        ],
+        {
+            synchronousExecution: true,
+            modalBehavior: 'execute',
+        }
+    )
+}
+
+async function createMaskExe() {
+    const { executeAsModal } = require('photoshop').core
+    await executeAsModal(createMaskCommand)
+}
+
+//unselect the rectangular marquee selection area
+async function unSelectMarqueeCommand() {
+    const batchPlay = require('photoshop').action.batchPlay
+
+    const result = await batchPlay(
+        [
+            {
+                _obj: 'set',
+                _target: [
+                    {
+                        _ref: 'channel',
+                        _property: 'selection',
+                    },
+                ],
+                to: {
+                    _enum: 'ordinal',
+                    _value: 'none',
+                },
+                _options: {
+                    dialogOptions: 'dontDisplay',
+                },
+            },
+        ],
+        {
+            synchronousExecution: true,
+            modalBehavior: 'execute',
+        }
+    )
+
+    return result
+}
+async function unSelectMarqueeExe() {
+    try {
+        await executeAsModal(unSelectMarqueeCommand)
+    } catch (e) {
+        console.warn(e)
+    }
+}
+
+//REFACTOR: move to selection.js
+async function selectMarqueeRectangularToolExe() {
+    async function selectMarqueeRectangularToolCommand() {
+        const result = await batchPlay(
+            [
+                {
+                    _obj: 'select',
+                    _target: [
+                        {
+                            _ref: 'marqueeRectTool',
+                        },
+                    ],
+                    _options: {
+                        dialogOptions: 'dontDisplay',
+                    },
+                },
+            ],
+            {
+                synchronousExecution: true,
+                modalBehavior: 'execute',
+            }
+        )
+        return result
+    }
+    await executeAsModal(async () => {
+        await selectMarqueeRectangularToolCommand()
+    })
+}
+
+async function promptForMarqueeTool() {
+    console.warn('promptForMarqueeTool is deprecated use Notification class')(
+        async () => {
+            const r1 = await dialog_box.prompt(
+                'Please Select a Rectangular Area',
+                'You Forgot to select a Rectangular Area',
+                ['Cancel', 'Rectangular Marquee']
+            )
+            if ((r1 || 'Rectangular Marquee') !== 'Rectangular Marquee') {
+                /* cancelled or No */
+                console.log('cancel')
+            } else {
+                /* Yes */
+                console.log('Rectangular Marquee')
+                selectMarqueeRectangularToolExe()
+            }
+        }
+    )()
+}
+
+async function selectLayerChannelCommand() {
+    //   const result = await batchPlay(
+    //     [
+    //       {
+    //         _obj: 'set',
+    //         _target: [
+    //           {
+    //             _ref: 'channel',
+    //             _property: 'selection'
+    //           }
+    //         ],
+    //         to: {
+    //           _ref: [
+    //             {
+    //               _ref: 'channel',
+    //               _enum: 'channel',
+    //               _value: 'transparencyEnum'
+    //             },
+    //             {
+    //               _ref: 'layer',
+    //               _name: 'Group 5'
+    //             }
+    //           ]
+    //         },
+    //         _options: {
+    //           dialogOptions: 'dontDisplay'
+    //         }
+    //       }
+    //     ],
+    //     {
+    //       synchronousExecution: false,
+    //       modalBehavior: 'execute'
+    //     }
+    //   )
+    const batchPlay = require('photoshop').action.batchPlay
+
+    const result = await batchPlay(
+        [
+            {
+                _obj: 'set',
+                _target: [
+                    {
+                        _ref: 'channel',
+                        _property: 'selection',
+                    },
+                ],
+                to: {
+                    _ref: 'channel',
+                    _enum: 'channel',
+                    _value: 'transparencyEnum',
+                },
+                _options: {
+                    dialogOptions: 'dontDisplay',
+                },
+            },
+        ],
+        {
+            synchronousExecution: true,
+            modalBehavior: 'execute',
+        }
+    )
+}
+
+async function getSelectionInfoCommand() {
+    // console.warn('getSelectionInfoCommand is deprecated use SelectionInfoDesc')
+    const result = await batchPlay(
+        [
+            {
+                _obj: 'get',
+                _target: [
+                    {
+                        _property: 'selection',
+                    },
+                    {
+                        _ref: 'document',
+                        _id: app.activeDocument._id,
+                    },
+                ],
+                _options: {
+                    dialogOptions: 'dontDisplay',
+                },
+            },
+        ],
+        {
+            synchronousExecution: true,
+            modalBehavior: 'execute',
+        }
+    )
+
+    return result
+}
+
+function isSelectionValid(selection) {
+    // console.warn(
+    //     'isSelectionValid is deprecated use selection.isSelectionValid instead'
+    // )
+    if (
+        selection && // check if the selection is defined
+        selection.hasOwnProperty('left') &&
+        selection.hasOwnProperty('right') &&
+        selection.hasOwnProperty('top') &&
+        selection.hasOwnProperty('bottom')
+    ) {
+        return true
+    }
+
+    return false
+}
+
+async function getSelectionInfoExe() {
+    // console.log('getSelectionInfo was called')
+    // console.warn(
+    //     'getSelectionInfoExe is deprecated use selection.getSelectionInfoExe instead'
+    // )
+    try {
+        const selection = (await executeAsModal(getSelectionInfoCommand))[0]
+            .selection
+
+        if (isSelectionValid(selection)) {
+            let selection_info = {
+                left: selection.left._value,
+                right: selection.right._value,
+                bottom: selection.bottom._value,
+                top: selection.top._value,
+                height: selection.bottom._value - selection.top._value,
+                width: selection.right._value - selection.left._value,
+            }
+            // console.dir({selection_info})
+            return selection_info
+        }
+    } catch (e) {
+        console.warn('selection info error', e)
+    }
+}
+
+async function reSelectMarqueeCommand(selectionInfo) {
+    const result = await batchPlay(
+        [
+            {
+                _obj: 'set',
+                _target: [
+                    {
+                        _ref: 'channel',
+                        _property: 'selection',
+                    },
+                ],
+                to: {
+                    _obj: 'rectangle',
+                    top: {
+                        _unit: 'pixelsUnit',
+                        _value: selectionInfo.top,
+                    },
+                    left: {
+                        _unit: 'pixelsUnit',
+                        _value: selectionInfo.left,
+                    },
+                    bottom: {
+                        _unit: 'pixelsUnit',
+                        _value: selectionInfo.bottom,
+                    },
+                    right: {
+                        _unit: 'pixelsUnit',
+                        _value: selectionInfo.right,
+                    },
+                },
+                _options: {
+                    dialogOptions: 'dontDisplay',
+                },
+            },
+        ],
+        {
+            synchronousExecution: true,
+            modalBehavior: 'execute',
+        }
+    )
+}
+async function reSelectMarqueeExe(selectionInfo) {
+    try {
+        if (isSelectionValid(selectionInfo)) {
+            //only try to reactivate the selection area if it is valid
+            await executeAsModal(async () => {
+                await reSelectMarqueeCommand(selectionInfo)
+            })
+        }
+    } catch (e) {
+        console.warn(e)
+    }
+}
+
+async function snapshot_layer() {
+    let psAction = require('photoshop').action
+    // const ids = (await app.activeDocument.activeLayers).map(layer => layer.id)
+    const ids = await app.activeDocument.layers.map((layer) => layer.id)
+    let command = [
+        // Select All Layers current layer
+        {
+            _obj: 'selectAllLayers',
+            _target: [
+                { _enum: 'ordinal', _ref: 'layer', _value: 'targetEnum' },
+            ],
+        },
+        // Duplicate current layer
+        // {"ID":[459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513],"_obj":"duplicate","_target":[{"_enum":"ordinal","_ref":"layer","_value":"targetEnum"}],"version":5},
+        {
+            ID: ids,
+            _obj: 'duplicate',
+            _target: [
+                { _enum: 'ordinal', _ref: 'layer', _value: 'targetEnum' },
+            ],
+            // version: 5
+        },
+
+        // Merge Layers
+        { _obj: 'mergeLayersNew' },
+        // Make
+        {
+            _obj: 'make',
+            at: { _enum: 'channel', _ref: 'channel', _value: 'mask' },
+            new: { _class: 'channel' },
+            using: { _enum: 'userMaskEnabled', _value: 'revealSelection' },
+        },
+        // Set Selection
+        {
+            _obj: 'set',
+            _target: [{ _property: 'selection', _ref: 'channel' }],
+            to: { _enum: 'ordinal', _ref: 'channel', _value: 'targetEnum' },
+        },
+    ]
+    const result = await psAction.batchPlay(command, {
+        synchronousExecution: true,
+        modalBehavior: 'execute',
+    })
+    console.log('snapshot_layer: result: ', result)
+    return result
+}
+async function snapshot_layer_new() {
+    //similar to snapshot_layer() but fixes the problem with smart effects
+
+    let psAction = require('photoshop').action
+
+    const ids = await app.activeDocument.layers.map((layer) => layer.id)
+    const selection_info = await getSelectionInfoExe()
+
+    let create_snapshot_layer_command = [
+        // Select All Layers current layer
+        {
+            _obj: 'selectAllLayers',
+            _target: [
+                { _enum: 'ordinal', _ref: 'layer', _value: 'targetEnum' },
+            ],
+        },
+        // Duplicate current layer
+
+        {
+            ID: ids,
+            _obj: 'duplicate',
+            _target: [
+                { _enum: 'ordinal', _ref: 'layer', _value: 'targetEnum' },
+            ],
+            // version: 5
+        },
+
+        // Merge Layers
+        { _obj: 'mergeLayersNew' },
+    ]
+    const result = await psAction.batchPlay(create_snapshot_layer_command, {
+        synchronousExecution: true,
+        modalBehavior: 'execute',
+    })
+    await reSelectMarqueeExe(selection_info) //reselect the selection area for the mask
+    //make a mask of the selection area
+    const make_mask_command = [
+        // Make
+        {
+            _obj: 'make',
+            at: { _enum: 'channel', _ref: 'channel', _value: 'mask' },
+            new: { _class: 'channel' },
+            using: { _enum: 'userMaskEnabled', _value: 'revealSelection' },
+        },
+        // // Set Selection
+        // {
+        //     _obj: 'set',
+        //     _target: [{ _property: 'selection', _ref: 'channel' }],
+        //     to: { _enum: 'ordinal', _ref: 'channel', _value: 'targetEnum' },
+        // },
+    ]
+    const result_2 = await psAction.batchPlay(make_mask_command, {
+        synchronousExecution: true,
+        modalBehavior: 'execute',
+    })
+    await reSelectMarqueeExe(selection_info) //reselect the selection area again so we don't break other functionality
+
+    console.log('snapshot_layer: result: ', result)
+    return result
+}
+
+async function snapshot_layerExe() {
+    try {
+        await executeAsModal(
+            async () => {
+                await snapshot_layer_new()
+            },
+            {
+                commandName: 'Action Commands',
+            }
+        )
+    } catch (e) {
+        console.error(e)
+    }
+}
+
+async function snapshot_layer_no_slide() {
+    let psAction = require('photoshop').action
+    // const ids = (await app.activeDocument.activeLayers).map(layer => layer.id)
+    const ids = await app.activeDocument.layers.map((layer) => layer.id)
+    let command = [
+        // Select All Layers current layer
+        {
+            _obj: 'selectAllLayers',
+            _target: [
+                { _enum: 'ordinal', _ref: 'layer', _value: 'targetEnum' },
+            ],
+        },
+        // Duplicate current layer
+        // {"ID":[459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513],"_obj":"duplicate","_target":[{"_enum":"ordinal","_ref":"layer","_value":"targetEnum"}],"version":5},
+        {
+            ID: ids,
+            _obj: 'duplicate',
+            _target: [
+                { _enum: 'ordinal', _ref: 'layer', _value: 'targetEnum' },
+            ],
+            // version: 5
+        },
+
+        // // Merge Layers
+        // { _obj: 'mergeLayersNew' },
+        // // Make
+        // {
+        //     _obj: 'make',
+        //     at: { _enum: 'channel', _ref: 'channel', _value: 'mask' },
+        //     new: { _class: 'channel' },
+        //     using: { _enum: 'userMaskEnabled', _value: 'revealSelection' },
+        // },
+        // // Set Selection
+        // {
+        //     _obj: 'set',
+        //     _target: [{ _property: 'selection', _ref: 'channel' }],
+        //     to: { _enum: 'ordinal', _ref: 'channel', _value: 'targetEnum' },
+        // },
+    ]
+    const result = await psAction.batchPlay(command, {
+        synchronousExecution: true,
+        modalBehavior: 'execute',
+    })
+    console.log('snapshot_layer: result: ', result)
+    return result
+}
+
+async function snapshot_layer_no_slide_Exe() {
+    try {
+        await executeAsModal(
+            async () => {
+                await snapshot_layer_no_slide()
+            },
+            {
+                commandName: 'Action Commands',
+            }
+        )
+    } catch (e) {
+        console.error(e)
+    }
+}
+
+// await runModalFunction();
+
+async function fillAndGroup() {
+    let result
+    let psAction = require('photoshop').action
+
+    // let newCommand =[
+    //   // snapshotLayer
+
+    //   // makeGroupCommand
+
+    //   // Make fill layer
+    //   {"_obj":"make","_target":[{"_ref":"contentLayer"}],"using":{"_obj":"contentLayer","type":{"_obj":"solidColorLayer","color":{"_obj":"RGBColor","blue":255.0,"grain":255.0,"red":255.0}}}},
+
+    // ]
+
+    let command = [
+        // Make fill layer
+        {
+            _obj: 'make',
+            _target: [{ _ref: 'contentLayer' }],
+            using: {
+                _obj: 'contentLayer',
+                type: {
+                    _obj: 'solidColorLayer',
+                    color: {
+                        _obj: 'RGBColor',
+                        blue: 255.0,
+                        grain: 255.0,
+                        red: 255.0,
+                    },
+                },
+            },
+        },
+        // Move current layer
+        // {"_obj":"move","_target":[{"_enum":"ordinal","_ref":"layer","_value":"targetEnum"}],"adjustment":false,"layerID":[17],"to":{"_index":7,"_ref":"layer"},"version":5},
+        // Select layer “Layer 4 copy”
+        // {"_obj":"select","_target":[{"_name":"Layer 4 copy","_ref":"layer"}],"layerID":[17,15],"makeVisible":false,"selectionModifier":{"_enum":"selectionModifierType","_value":"addToSelectionContinuous"}},
+        // Make Group
+        // {"_obj":"make","_target":[{"_ref":"layerSection"}],"from":{"_enum":"ordinal","_ref":"layer","_value":"targetEnum"},"layerSectionEnd":19,"layerSectionStart":18,"name":"Group 1"}
+    ]
+    const snapshotLayer = await app.activeDocument.activeLayers[0]
+    await makeGroupCommand()
+    const groupLayer = app.activeDocument.activeLayers[0]
+    result = await psAction.batchPlay(command, {})
+    const fillLayer = app.activeDocument.activeLayers[0]
+    snapshotLayer.moveAbove(fillLayer)
+    // await app.activeDocument.activeLayers[0].moveAbove()
+    // const layerIDs = []
+    // const to_index = await getIndexCommand(groupLayer.id)
+    // await moveToGroupCommand(to_index, layerIDs)
+}
+
+async function fillAndGroupExe() {
+    await require('photoshop').core.executeAsModal(fillAndGroup, {
+        commandName: 'Action Commands',
+    })
+}
+async function fastSnapshot() {
+    await snapshot_layerExe()
+    await fillAndGroupExe()
+}
+
+function layerToFileName(layer, session_id) {
+    file_name = `${layer.name}_${layer.id}_${session_id}`
+    return file_name
+}
+function layerNameToFileName(layer_name, layer_id, session_id) {
+    file_name = `${layer_name}_${layer_id}_${session_id}`
+    return file_name
+}
+
+async function silentSetInitImage(layer, session_id) {
+    try {
+        const html_manip = require('./utility/html_manip')
+        const io = require('./utility/io')
+        // const layer = await app.activeDocument.activeLayers[0]
+        const old_name = layer.name
+
+        // image_name = await app.activeDocument.activeLayers[0].name
+
+        //convert layer name to a file name
+        let image_name = layerNameToFileName(old_name, layer.id, session_id)
+        image_name = `${image_name}.png`
+
+        //the width and height of the exported image
+        const width = html_manip.getWidth()
+        const height = html_manip.getHeight()
+
+        //get the selection from the canvas as base64 png, make sure to resize to the width and height slider
+        const selectionInfo = g_generation_session.selectionInfo
+        // const base64_image = await io.IO.getSelectionFromCanvasAsBase64Silent(
+        //     selectionInfo,
+        //     true,
+        //     width,
+        //     height
+        // )
+
+        const use_silent_mode = html_manip.getUseSilentMode()
+        // if (use_silent_mode) {
+        //     base64_image = await io.IO.getSelectionFromCanvasAsBase64Silent(
+        //         selectionInfo,
+        //         true,
+        //         width,
+        //         height
+        //     )
+        // } else {
+        //     base64_image = await io.IO.getSelectionFromCanvasAsBase64NonSilent(
+        //         layer,
+
+        //         image_name,
+        //         width,
+        //         height
+        //     )
+        // }
+        const base64_image =
+            await io.IO.getSelectionFromCanvasAsBase64Interface(
+                width,
+                height,
+                layer,
+                selectionInfo,
+                true,
+                use_silent_mode,
+                image_name
+            )
+        //save base64 as file in the init_images directory
+        const init_entry = await getInitImagesDir()
+        await io.IO.base64PngToPngFile(base64_image, init_entry, image_name)
+
+        g_init_image_name = image_name
+        console.log(image_name)
+
+        const path = `${g_init_images_dir}/${image_name}`
+
+        //store the base64 init image and also set it as the active/latest init image
+        g_generation_session.base64initImages[path] = base64_image
+        g_generation_session.activeBase64InitImage = base64_image
+
+        const init_src = base64ToSrc(g_generation_session.activeBase64InitImage)
+        html_manip.setInitImageSrc(init_src)
+
+        return (image_info = { name: image_name, base64: base64_image })
+    } catch (e) {
+        console.error(`psapi.js silentSetInitImage error:, ${e}`)
+    }
+}
+async function silentSetInitImageMask(layer, session_id) {
+    try {
+        const html_manip = require('./utility/html_manip')
+
+        // const layer = await app.activeDocument.activeLayers[0]
+        const old_name = layer.name
+
+        image_name = layerNameToFileName(old_name, layer.id, session_id)
+        image_name = `${image_name}.png`
+        const width = html_manip.getWidth()
+        const height = html_manip.getHeight()
+
+        //get the selection from the canvas as base64 png, make sure to resize to the width and height slider
+        const selectionInfo = g_generation_session.selectionInfo
+
+        const use_silent_mode = html_manip.getUseSilentMode()
+
+        const base64_image =
+            await io.IO.getSelectionFromCanvasAsBase64Interface(
+                width,
+                height,
+                layer,
+                selectionInfo,
+                true,
+                use_silent_mode,
+                image_name
+            )
+
+        //save base64 as file in the init_images directory
+        const init_entry = await getInitImagesDir()
+        await io.IO.base64PngToPngFile(base64_image, init_entry, image_name)
+
+        g_init_image_mask_name = image_name // this is the name we will send to the server
+
+        console.log(image_name)
+
+        const path = `${g_init_images_dir}/${image_name}`
+        g_generation_session.base64maskImage[path] = base64_image
+        g_generation_session.activeBase64MaskImage = base64_image
+
+        const mask_src = base64ToSrc(g_generation_session.activeBase64MaskImage)
+        html_manip.setInitImageMaskSrc(mask_src)
+        return (image_info = { name: image_name, base64: base64_image })
+    } catch (e) {
+        console.error(`psapi.js setInitImageMask error: `, e)
+    }
+}
+async function setInitImage(layer, session_id) {
+    try {
+        const html_manip = require('./utility/html_manip')
+        // const layer = await app.activeDocument.activeLayers[0]
+        const old_name = layer.name
+
+        // image_name = await app.activeDocument.activeLayers[0].name
+
+        //convert layer name to a file name
+        let image_name = layerNameToFileName(old_name, layer.id, session_id)
+        image_name = `${image_name}.png`
+
+        //the width and height of the exported image
+        const width = html_manip.getWidth()
+        const height = html_manip.getHeight()
+        const image_buffer = await newExportPng(
+            layer,
+            image_name,
+            width,
+            height
+        )
+        const base64_image = _arrayBufferToBase64(image_buffer) //convert the buffer to base64
+        //send the base64 to the server to save the file in the desired directory
+        await sdapi.requestSavePng(base64_image, image_name)
+
+        g_init_image_name = image_name
+        console.log(image_name)
+
+        const image_src = await sdapi.getInitImage(g_init_image_name)
+        let ini_image_element = document.getElementById('init_image')
+        ini_image_element.src = image_src
+        const path = `${g_init_images_dir}/${image_name}`
+
+        g_generation_session.base64initImages[path] = base64_image
+        g_generation_session.activeBase64InitImage =
+            g_generation_session.base64initImages[path]
+
+        const init_src = base64ToSrc(g_generation_session.activeBase64InitImage)
+        html_manip.setInitImageSrc(init_src)
+
+        return (image_info = { name: image_name, base64: base64_image })
+    } catch (e) {
+        console.error(`psapi.js setInitImage error:, ${e}`)
+    }
+}
+async function setInitImageMask(layer, session_id) {
+    try {
+        const html_manip = require('./utility/html_manip')
+
+        // const layer = await app.activeDocument.activeLayers[0]
+        const old_name = layer.name
+
+        //get the active layer name
+        // image_name = await app.activeDocument.activeLayers[0].name
+        // image_name = layerNameToFileName(old_name,layer.id,random_session_id)
+        image_name = layerNameToFileName(old_name, layer.id, session_id)
+        image_name = `${image_name}.png`
+        const width = html_manip.getWidth()
+        const height = html_manip.getHeight()
+        image_buffer = await newExportPng(layer, image_name, width, height)
+        g_init_image_mask_name = image_name // this is the name we will send to the server
+        // g_init_mask_layer = layer
+        // g_mask_related_layers = {}
+
+        console.log(image_name)
+        base64_image = _arrayBufferToBase64(image_buffer) //convert the buffer to base64
+        //send the base64 to the server to save the file in the desired directory
+        await sdapi.requestSavePng(base64_image, image_name)
+
+        const image_src = await sdapi.getInitImage(g_init_image_mask_name) // we should replace this with getInitImagePath which return path to local disk
+        const ini_image_mask_element =
+            document.getElementById('init_image_mask')
+        ini_image_mask_element.src = image_src
+        ini_image_mask_element.dataset.layer_id = layer.id
+
+        const path = `${g_init_images_dir}/${image_name}`
+        g_generation_session.base64maskImage[path] = base64_image
+        g_generation_session.activeBase64MaskImage =
+            g_generation_session.base64maskImage[path]
+        //create viewer init image obj
+        {
+        }
+        // return image_name
+        const mask_src = base64ToSrc(g_generation_session.activeBase64MaskImage)
+        html_manip.setInitImageMaskSrc(mask_src)
+        return (image_info = { name: image_name, base64: base64_image })
+    } catch (e) {
+        console.error(`psapi.js setInitImageMask error: `, e)
+    }
+}
+
+// remove the generated mask related layers from the canvas and "layers" panel
+
+// async function cleanSnapAndFill(layers){
+//   // we can delete this function and use cleanLayers() instead
+//   //delete init image group
+//   //delete init image (snapshot layer)
+//   //delete fill layer
+
+//   for (layer of layers){
+//     try{
+
+//       await executeAsModal(async ()=>{await layer.delete()})
+//     }catch(e){
+//       console.warn("cleanSnapAndFill, issue deleting a layer",e)
+//     }
+//   }
+// return []
+// }
+
+async function cleanLayers(layers) {
+    // g_init_image_related_layers = {}
+    // g_mask_related_layers = {}
+    // await loadViewerImages()// we should move loadViewerImages to a new file viewer.js
+    console.log('cleanLayers() -> layers:', layers)
+    for (layer of layers) {
+        try {
+            if (layer_util.Layer.doesLayerExist(layer)) {
+                await executeAsModal(async () => {
+                    await layer.delete()
+                })
+            }
+        } catch (e) {
+            console.warn(
+                'warning attempting to a delete layer,layer.name: ',
+                layer.name,
+                layer,
+                e
+            )
+            continue
+        }
+    }
+    return []
+}
+
+// async function cleanLayersOutpaint(layers){
+//   //delete group mask layer
+//   //delete mask layer
+//   //delete group init image layer
+//   //delete init image layer (snapshot layer)
+//   //delete fill layer
+
+//   for (layer of layers){
+//     try {
+//       await executeAsModal(async ()=>{await layer.delete()})}
+//       catch(e){
+//         console.warn("warning attempting to a delete layer: ",e)
+//       }
+//   }
+
+// return []
+// }
+// async function cleanLayersInpaint(layers){
+//   //delete group mask layer
+//   //delete white mask layer
+//   //delete the black fill layer
+//   //delete init image layer (snapshot layer)
+
+//   for (layer of layers){
+//     await executeAsModal(async ()=>{await layer.delete()})
+//   }
+
+// return []
+// }
+async function createClippingMaskExe() {
+    const batchPlay = require('photoshop').action.batchPlay
+
+    async function createClippingMaskCommand() {
+        const result = await batchPlay(
+            [
+                {
+                    _obj: 'make',
+                    new: {
+                        _class: 'channel',
+                    },
+                    at: {
+                        _ref: 'channel',
+                        _enum: 'channel',
+                        _value: 'mask',
+                    },
+                    using: {
+                        _enum: 'userMaskEnabled',
+                        _value: 'revealSelection',
+                    },
+                    _options: {
+                        dialogOptions: 'dontDisplay',
+                    },
+                },
+            ],
+            {
+                synchronousExecution: true,
+                modalBehavior: 'execute',
+            }
+        )
+    }
+
+    await executeAsModal(async () => {
+        await createClippingMaskCommand()
+    })
+}
+//REFACTOR: delete and replace with getSelectionInfoExe()
+async function checkIfSelectionAreaIsActive() {
+    try {
+        let isSelectionAreaValid = await getSelectionInfoExe()
+        return isSelectionAreaValid
+    } catch (e) {
+        console.warn(e)
+    }
+}
+async function saveUniqueDocumentIdExe(new_id) {
+    const batchPlay = require('photoshop').action.batchPlay
+
+    async function saveUniqueDocumentIdCommand() {
+        const batchPlay = require('photoshop').action.batchPlay
+
+        const result = await batchPlay(
+            [
+                {
+                    _obj: 'set',
+                    _target: [
+                        {
+                            _ref: 'property',
+                            _property: 'fileInfo',
+                        },
+                        {
+                            _ref: 'document',
+                            _enum: 'ordinal',
+                            _value: 'targetEnum',
+                        },
+                    ],
+                    to: {
+                        _obj: 'fileInfo',
+                        caption: new_id,
+                        keywords: [new_id],
+                    },
+                    _options: {
+                        dialogOptions: 'dontDisplay',
+                    },
+                },
+            ],
+            {
+                synchronousExecution: true,
+                modalBehavior: 'execute',
+            }
+        )
+    }
+
+    await executeAsModal(async () => {
+        await saveUniqueDocumentIdCommand()
+    })
+}
+
+async function readUniqueDocumentIdExe() {
+    const batchPlay = require('photoshop').action.batchPlay
+
+    async function readUniqueDocumentIdCommand() {
+        const batchPlay = require('photoshop').action.batchPlay
+
+        const result = await batchPlay(
+            [
+                {
+                    _obj: 'get',
+                    _target: [
+                        {
+                            _ref: 'property',
+                            _property: 'fileInfo',
+                        },
+                        {
+                            _ref: 'document',
+                            _enum: 'ordinal',
+                            _value: 'targetEnum',
+                        },
+                    ],
+                    // to: {
+                    //   _obj: 'fileInfo',
+                    //   caption: new_id,
+                    //   keywords: [new_id]
+                    // },
+                    _options: {
+                        dialogOptions: 'dontDisplay',
+                    },
+                },
+            ],
+            {
+                synchronousExecution: true,
+                modalBehavior: 'execute',
+            }
+        )
+        console.log('readUniqueDocumentIdCommand: result ', result)
+        return result
+    }
+
+    let uniqueDocumentId = ''
+    try {
+        await executeAsModal(async () => {
+            uniqueDocumentId = (await readUniqueDocumentIdCommand())[0].fileInfo
+                .caption
+            if (typeof uniqueDocumentId === 'string') {
+                uniqueDocumentId = uniqueDocumentId.trim()
+            }
+        })
+    } catch (e) {
+        console.warn('readUniqueDocumentIdExe: ', e)
+        uniqueDocumentId = ''
+    }
+
+    return uniqueDocumentId
+}
+
+const readPng = async (image_name) => {
+    //it will save the document then read it. store it in memory
+    // image_name = 'test.png'
+    try {
+        let img_buffer
+        await executeAsModal(
+            async (control) => {
+                const folder = await fs.getTemporaryFolder()
+                // const pluginFolder = await fs.getPluginFolder()
+
+                // let init_images_dir = await pluginFolder.getEntry(
+                //     './server/python_server/init_images'
+                // )
+
+                const file = await folder.createFile(image_name, {
+                    overwrite: true,
+                })
+
+                const currentDocument = app.activeDocument
+                await currentDocument.saveAs.png(
+                    file,
+                    // {
+                    //   compression: 6,
+                    // },
+                    null,
+                    true
+                )
+
+                const arrayBuffer = await file.read({ format: formats.binary })
+                // console.log(arrayBuffer, 'arrayBuffer') ;
+                img_buffer = arrayBuffer
+            },
+
+            { commandName: 'readPng' }
+        )
+
+        return img_buffer
+    } catch (e) {
+        console.warn(e)
+    }
+}
+
+async function selectCanvasCommand() {
+    // const result = await batchPlay(
+    // [
+    //    {
+    //       _obj: "historyStateChanged",
+    //       documentID: 1044,
+    //       ID: 1058,
+    //       name: "Select Canvas",
+    //       hasEnglish: true,
+    //       itemIndex: 7,
+    //       commandID: 1017,
+    //       _options: {
+    //          dialogOptions: "dontDisplay"
+    //       }
+    //    }
+    // ],{
+    //    synchronousExecution: true,
+    //    modalBehavior: "execute"
+    // });
+
+    const result = await batchPlay(
+        [
+            {
+                _obj: 'set',
+                _target: [
+                    {
+                        _ref: 'channel',
+                        _property: 'selection',
+                    },
+                ],
+                to: {
+                    _enum: 'ordinal',
+                    _value: 'allEnum',
+                },
+                _options: {
+                    dialogOptions: 'dontDisplay',
+                },
+            },
+        ],
+        {
+            synchronousExecution: true,
+            modalBehavior: 'execute',
+        }
+    )
+
+    return result
+}
+async function selectCanvasExe() {
+    await executeAsModal(
+        async () => {
+            await selectCanvasCommand()
+        },
+        { commandName: 'selectCanvasExe' }
+    )
+}
+async function newExportPng(layer, image_name, width, height) {
+    //store layers we want to export in variables
+    // let layerToExports =
+    // create new document
+    // duplicate the layers to the new documnet
+    //select the layer channel selectLayerChannelCommand
+    //document.crop
+    //export using readPng()
+
+    try {
+        //get the active layers
+        // const layersToExport = app.activeDocument.activeLayers
+
+        //create new document
+        // let exportDoc = await executeAsModal(app.documents.add)
+        let exportDoc
+        const makeDoc = async () => {
+            let exportDoc = await app.documents.add({
+                width: width,
+                height: height,
+                resolution: await app.activeDocument.resolution,
+                mode: 'RGBColorMode',
+                fill: 'transparent',
+            })
+        }
+        let image_buffer
+        await executeAsModal(
+            async () => {
+                // await app.documents.add()
+                await makeDoc()
+                exportDoc = app.activeDocument
+
+                console.log('exportDoc.id: ', exportDoc.id)
+                // for (layer of layersToExport) {
+
+                console.log(layer.id)
+                const dupLayer = await layer.duplicate(exportDoc)
+                await selectLayers([dupLayer])
+                // await selectLayerChannelCommand()
+                await selectCanvasExe()
+                const canvas_selection_info = await getSelectionInfoExe()
+                await layerToSelection(canvas_selection_info)
+                // const selection_info = await getSelectionInfoExe()
+                // await exportDoc.crop(selection_info)
+                // export_image_name = `${layer.name}.png`
+                image_buffer = await readPng(image_name)
+                await exportDoc.closeWithoutSaving()
+            },
+            { commandName: 'NewExportPng' }
+        )
+        return image_buffer
+        // }
+    } catch (e) {
+        console.error(`newExportPng error: ,${e}`)
+    }
+}
+
+async function tempExportPng(layer, image_name, width, height) {
+    //store layers we want to export in variables
+    // let layerToExports =
+    // create new document
+    // duplicate the layers to the new documnet
+    //select the layer channel selectLayerChannelCommand
+    //document.crop
+    //export using readPng()
+
+    try {
+        //get the active layers
+        // const layersToExport = app.activeDocument.activeLayers
+
+        //create new document
+        // let exportDoc = await executeAsModal(app.documents.add)
+        let exportDoc
+        const makeDoc = async () => {
+            let exportDoc = await app.documents.add({
+                width: width,
+                height: height,
+                resolution: await app.activeDocument.resolution,
+                mode: 'RGBColorMode',
+                fill: 'transparent',
+            })
+        }
+        await executeAsModal(
+            async () => {
+                // await app.documents.add()
+                await makeDoc()
+                exportDoc = app.activeDocument
+
+                console.log('exportDoc.id: ', exportDoc.id)
+                // for (layer of layersToExport) {
+
+                console.log(layer.id)
+                const dupLayer = await layer.duplicate(exportDoc)
+                await selectLayers([dupLayer])
+                // await selectLayerChannelCommand()
+                await selectCanvasExe()
+                const canvas_selection_info = await getSelectionInfoExe()
+                await layerToSelection(canvas_selection_info)
+                // const selection_info = await getSelectionInfoExe()
+                // await exportDoc.crop(selection_info)
+                // export_image_name = `${layer.name}.png`
+                await readPng(image_name)
+                await exportDoc.closeWithoutSaving()
+            },
+            { commandName: 'tempExportPng' }
+        )
+        // }
+    } catch (e) {
+        console.error(`newExportPng error: ,${e}`)
+    }
+}
+async function mergeVisibleCommand() {
+    const result = await batchPlay(
+        [
+            {
+                _obj: 'mergeVisible',
+                duplicate: true,
+                _isCommand: true,
+                // "_options": {
+                //   // "dialogOptions": "dontDisplay"
+                // }
+            },
+        ],
+        {
+            synchronousExecution: true,
+            modalBehavior: 'execute',
+        }
+    )
+
+    return result
+}
+
+async function mergeVisibleExe() {
+    await executeAsModal(async () => {
+        await mergeVisibleCommand()
+    })
+}
+
+async function layerToSelection(selection_info) {
+    //store active layer for later
+
+    try {
+        //Store selection info
+        //unSelect
+        //move layer
+        //scale layer
+        //Select from selection info
+        // let selection_info = await getSelectionInfo()
+
+        console.log('selection_info:', selection_info)
+
+        console.log('unSelect')
+
+        function getLayerSize(layer) {
+            console.log('layer.bounds:')
+            console.dir(layer.bounds)
+            const bounds = layer.bounds
+            const height = bounds.bottom - bounds.top
+            const width = bounds.right - bounds.left
+            return {
+                height: height,
+                width: width,
+                left: bounds.left,
+                right: bounds.right,
+                top: bounds.top,
+                bottom: bounds.bottom,
+            }
+        }
+        //scale layer
+        async function scaleLayer(layer, selection_info) {
+            console.log('scaleLayer got called')
+            // const activeLayer = getActiveLayer()
+            // const activeLayer = await app.activeDocument.activeLayers[0]
+
+            let layer_info = getLayerSize(layer)
+            scale_x_ratio = (selection_info.width / layer_info.width) * 100
+            scale_y_ratio = (selection_info.height / layer_info.height) * 100
+            console.log('scale_x_y_ratio:', scale_x_ratio, scale_y_ratio)
+            await layer.scale(scale_x_ratio, scale_y_ratio)
+        }
+
+        async function moveLayerExe(layerToMove, selection_info) {
+            let layer_info = getLayerSize(layerToMove)
+            top_dist = layer_info.top - selection_info.top
+            left_dist = layer_info.left - selection_info.left
+            await layerToMove.translate(-left_dist, -top_dist)
+        }
+        // const activeLayer = await getActiveLayer()
+
+        //store all active layers
+        const activeLayers = await app.activeDocument.activeLayers
+        await unSelectMarqueeExe()
+        // await executeAsModal(unSelect,  {'commandName': 'unSelect'})
+        // await executeAsModal(scaleLayer,  {'commandName': 'scaleLayer'})
+
+        await executeAsModal(
+            async () => {
+                for (let layer of activeLayers) {
+                    await selectLayers([layer]) // make sure only one layer is selected
+                    await scaleLayer(layer, selection_info) //scale to selection size
+                    await moveLayerExe(layer, selection_info) //move to selection
+                }
+            },
+            { commandName: 'moveLayerExe' }
+        )
+
+        // await reselect(selection_info)
+    } catch (e) {
+        console.warn(e)
+    }
+}
+function executeCommandExe(commandFunc) {
+    try {
+        ;(async () => {
+            await executeAsModal(async () => {
+                await commandFunc()
+            })
+        })()
+    } catch (e) {
+        console.warn(e)
+    }
+}
+async function executeDescExe(Desc) {
+    try {
+        await executeAsModal(async () => {
+            const result = await batchPlay([Desc], {
+                synchronousExecution: true,
+                modalBehavior: 'execute',
+            })
+            console.log(result)
+        })
+    } catch (e) {
+        console.warn(e)
+    }
+}
+module.exports = {
+    createSolidLayer,
+    createEmptyGroup,
+    getLayerIndex,
+    collapseGroup,
+    moveToGroupCommand,
+    MoveToGroupExe,
+    selectLayers,
+    selectLayersExe,
+    unselectActiveLayers,
+    unselectActiveLayersExe,
+    createMaskExe,
+    getSelectionInfoExe,
+    unSelectMarqueeCommand,
+    unSelectMarqueeExe,
+    reSelectMarqueeExe,
+    selectLayerChannelCommand,
+    snapshot_layer,
+    snapshot_layerExe,
+    fillAndGroupExe,
+    fastSnapshot,
+    setInitImage,
+    setInitImageMask,
+
+    layerToFileName,
+    layerNameToFileName,
+    // cleanLayersOutpaint,
+    // cleanLayersInpaint,
+    // cleanSnapAndFill,
+    cleanLayers,
+    createClippingMaskExe,
+    checkIfSelectionAreaIsActive,
+    selectMarqueeRectangularToolExe,
+    promptForMarqueeTool,
+    saveUniqueDocumentIdExe,
+    readUniqueDocumentIdExe,
+    newExportPng,
+    mergeVisibleExe,
+    selectCanvasExe,
+    layerToSelection,
+    isSelectionValid,
+    snapshot_layer_no_slide_Exe,
+    setVisibleExe,
+    silentSetInitImage,
+    silentSetInitImageMask,
+    executeCommandExe,
+    executeDescExe,
+}

Auto-Photoshop-StableDiffusion-Plugin/requirements.txt

@@ -0,0 +1,26 @@
+anyio==3.6.2
+asyncio==3.4.3
+certifi==2022.12.7
+charset-normalizer==2.1.1
+click==8.1.3
+fastapi==0.88.0
+h11==0.14.0
+httpcore==0.16.3
+httptools==0.5.0
+httpx==0.23.1
+idna==3.4
+Pillow==9.3.0
+pydantic==1.10.2
+python-dotenv==0.21.0
+PyYAML==6.0
+requests==2.28.1
+rfc3986==1.5.0
+sniffio==1.3.0
+starlette==0.22.0
+typing_extensions==4.4.0
+urllib3==1.26.13
+uvicorn==0.20.0
+# uvloop==0.17.0
+watchfiles==0.18.1
+websockets==10.4
+duckduckgo_search==3.7.1

Auto-Photoshop-StableDiffusion-Plugin/scripts/main.py

@@ -0,0 +1,105 @@
+from modules import scripts, processing, shared, images, devices, ui, lowvram
+import gradio
+import requests
+import time
+import PIL.Image
+import base64
+import io
+import os.path
+import numpy
+import itertools
+import gradio as gr
+import torch
+from fastapi import FastAPI
+from fastapi import APIRouter, Request
+from fastapi.responses import StreamingResponse
+from modules import script_callbacks, scripts, shared
+
+
+import sys
+python_server_dir = 'server/python_server'
+extension_dir = scripts.basedir()
+python_server_full_path = os.path.join(extension_dir,python_server_dir)
+print("python_server_full_path: ",python_server_full_path)
+sys.path.insert(0, python_server_full_path)
+import search
+import img2imgapi
+import serverMain
+
+router = APIRouter()
+
+# @router.get("/config")
+# async def get_state():
+#     print("hello get /config auto-photoshop-sd")
+#     res = "hello get /config auto-photoshop-sd"
+#     return {"res": res}
+
+@router.post('/search/image/')
+async def searchImage(request:Request):
+    try:
+        json = await request.json()
+    except: 
+        json = {}
+    
+
+    try:
+        keywords = json.get('keywords','cute cats') 
+        images = await search.imageSearch(keywords)
+        print(images)
+        
+        
+        return {"images":images}
+    except:
+        print("keywords",keywords)
+        # print(f'{request}')
+    return {"error": "error message: can't preform an image search"}
+
+
+@router.post('/mask/expansion/')
+async def maskExpansionHandler(request:Request):
+    try:
+        json = await request.json()
+    except: 
+        json = {}
+    
+    # print("mask expansion json :",json)
+    try:
+        # keywords = json.get('keywords','cute dogs') 
+        base64_mask_image = json['mask']
+        mask_expansion = json['mask_expansion']
+        #convert base64 to img
+        
+        await img2imgapi.base64ToPng(base64_mask_image,"original_mask.png")#save a copy of the mask
+
+        mask_image = img2imgapi.b64_2_img(base64_mask_image)
+        
+        expanded_mask_img = img2imgapi.maskExpansion(mask_image,mask_expansion)
+        base64_expanded_mask_image = img2imgapi.img_2_b64(expanded_mask_img)
+        await img2imgapi.base64ToPng(base64_expanded_mask_image,"expanded_mask.png")#save a copy of the mask
+
+
+        return {"mask":base64_expanded_mask_image}
+    
+    except:
+        # print("request",request)
+        raise Exception(f"couldn't preform mask expansion",json)
+    # return response
+    return {"error": "error message: can't preform an mask expansion"}
+
+
+
+def on_app_started(demo: gr.Blocks, app: FastAPI):
+    # print("hello on_app_started auto-photoshop-plugin")
+  
+    if shared.cmd_opts.api:
+        app.include_router(serverMain.router, prefix="/sdapi/auto-photoshop-sd", tags=['Auto Photoshop SD Plugin API'])
+        # app.include_router(router, prefix="/sdapi/auto-photoshop-sd", tags=['Auto Photoshop SD Plugin API'])
+
+        
+    else:
+        print("COMMANDLINE_ARGS does not contain --api, API won't be mounted.")
+        
+        # logger.warning("COMMANDLINE_ARGS does not contain --api, API won't be mounted.")
+    # if you wanted to do anything massive to the UI, you could modify demo, but why?
+
+script_callbacks.on_app_started(on_app_started)

Auto-Photoshop-StableDiffusion-Plugin/scripts/test.py

@@ -0,0 +1,5 @@
+# import sys
+# sys.path.insert(0, 'server/python_server')
+# import search
+
+# print("hello test.py")  

Auto-Photoshop-StableDiffusion-Plugin/sdapi_py_re.js

@@ -0,0 +1,814 @@
+const { getDummyBase64, getDummyBase64_2 } = require('./utility/dummy')
+const { base64ToBase64Url } = require('./utility/general')
+const { getExtensionType } = require('./utility/html_manip')
+const py_re = require('./utility/sdapi/python_replacement')
+const Enum = require('./enum')
+const control_net = require('./utility/tab/control_net')
+const api = require('./utility/api')
+//javascript plugin can't read images from local directory so we send a request to local server to read the image file and send it back to plugin as image string base64
+
+async function getInitImage(init_image_name) {
+    console.log('getInitImage(): get Init Image from the server :')
+    const payload = {
+        init_image_name: init_image_name,
+    }
+
+    // const full_url = 'http://127.0.0.1:8000/getInitImage/'
+    // console.log(full_url)
+    // console.log('getInitImage payload:', payload)
+    // let request = await fetch(full_url, {
+    //     method: 'POST',
+    //     headers: {
+    //         Accept: 'application/json',
+    //         'Content-Type': 'application/json',
+    //     },
+    //     body: JSON.stringify(payload),
+    //     // "body": payload
+    // })
+
+    // let json = await request.json()
+
+    // console.log('json:')
+    // console.dir(json)
+    // base64data = json.init_image_str
+    // image_src = `data:image/png;base64, ${base64data}`
+    console.warn('this function is deprecated!')
+    const image_src =
+        'https://im ages.pexels.com/photos/1386604/pexels-photo-1386604.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=1'
+    return image_src
+
+    // console.log(img.src)
+
+    // let img_blob =  await (await fetch(img.src)).blob()
+    // console.log("img_blob:")
+    // console.dir(img_blob)
+}
+//REFACTOR: move this function to io.js
+async function requestSavePng(base64_image, image_name) {
+    try {
+        console.log('requestSavePng():')
+
+        const uniqueDocumentId = await getUniqueDocumentId()
+        const folder = `${uniqueDocumentId}/init_images`
+        const init_entry = await getInitImagesDir()
+        saveFileInSubFolder(base64_image, folder, image_name)
+        console.warn('this function is deprecated')
+    } catch (e) {
+        console.warn(e)
+        return {}
+    }
+}
+async function requestTxt2Img(payload) {
+    try {
+        console.log('requestTxt2Img(): about to send a fetch request')
+
+        // const full_url = 'http://127.0.0.1:8000/txt2img/'
+        // console.log(full_url)
+
+        // let request = await fetch(full_url, {
+        //     method: 'POST',
+        //     headers: {
+        //         Accept: 'application/json',
+        //         'Content-Type': 'application/json',
+        //     },
+        //     body: JSON.stringify(payload),
+        //     // "body": payload
+        // })
+
+        // let json = await request.json()
+        let json = await py_re.txt2ImgRequest(payload)
+        console.log('requestTxt2Img json:', json)
+
+        return json
+    } catch (e) {
+        console.warn(e)
+        return {}
+    }
+}
+
+async function requestImg2Img(payload) {
+    console.log('requestImg2Img(): about to send a fetch request')
+    try {
+        // const full_url = 'http://127.0.0.1:8000/img2img/'
+        // console.log(full_url)
+        // console.log('requestImg2Img payload is: ', payload)
+        // let request = await fetch(full_url, {
+        //     method: 'POST',
+        //     headers: {
+        //         Accept: 'application/json',
+        //         'Content-Type': 'application/json',
+        //     },
+        //     body: JSON.stringify(payload),
+        //     // "body": payload
+        // })
+
+        // let json = await request.json()
+        let json = await py_re.img2ImgRequest(g_sd_url, payload)
+        console.log('requestImg2Img json:')
+        console.dir(json)
+
+        return json
+    } catch (e) {
+        console.warn(e)
+        return {}
+    }
+}
+
+async function requestProgress() {
+    let json = {}
+    try {
+        console.log('requestProgress: ')
+
+        const full_url = `${g_sd_url}/sdapi/v1/progress?skip_current_image=false`
+        let request = await fetch(full_url)
+        json = await request.json()
+        console.log('progress json:', json)
+
+        return json
+    } catch (e) {
+        console.warn(e)
+        // console.log('json: ', json)
+    }
+}
+
+async function requestGetModels() {
+    console.log('requestGetModels: ')
+    let json = []
+    const full_url = `${g_sd_url}/sdapi/v1/sd-models`
+    try {
+        let request = await fetch(full_url)
+        json = await request.json()
+        console.log('models json:')
+        console.dir(json)
+    } catch (e) {
+        console.warn(`issues requesting from ${full_url}`, e)
+    }
+    return json
+}
+
+async function requestGetSamplers() {
+    let json = null
+    try {
+        console.log('requestGetSamplers: ')
+
+        const full_url = `${g_sd_url}/sdapi/v1/samplers`
+        let request = await fetch(full_url)
+        json = await request.json()
+        console.log('samplers json:', json)
+    } catch (e) {
+        console.warn(e)
+    }
+    return json
+}
+
+async function requestSwapModel(model_title) {
+    console.log('requestSwapModel: ')
+    // const full_url = 'http://127.0.0.1:8000/swapModel'
+
+    const full_url = `${g_sd_url}/sdapi/v1/options`
+    payload = {
+        sd_model_checkpoint: model_title,
+    }
+    let request = await fetch(full_url, {
+        method: 'POST',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+        // "body": payload
+    })
+
+    let json = await request.json()
+
+    console.log('models json:')
+    console.dir(json)
+
+    return json
+}
+
+async function requestInterrupt() {
+    const full_url = `${g_sd_url}/sdapi/v1/interrupt`
+    try {
+        console.log('requestInterrupt: ')
+
+        payload = ''
+        let request = await fetch(full_url, {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            // body: JSON.stringify(payload)
+            // "body": payload
+        })
+
+        console.log('interrupt request:', request)
+        let json = await request.json()
+
+        return json
+    } catch (e) {
+        console.warn(e)
+    }
+}
+
+async function getVersionRequest() {
+    // version = "v0.0.0"
+    console.log('requestGetSamplers: ')
+    const current_version = g_version
+    // try {
+    //     const full_url = 'http://127.0.0.1:8000/version'
+    //     let request = await fetch(full_url)
+    //     let json = await request.json()
+    //     console.log('version json:', json)
+    //     version = json['version']
+
+    //     return version
+    // } catch (e) {
+    //     console.warn(e)
+    //     version = 'v0.0.0'
+
+    //     return version
+    // }
+    return current_version
+}
+
+async function changeSdUrl(new_sd_url) {
+    // version = "v0.0.0"
+    console.log('changeSdUrl: new_sd_url:', new_sd_url)
+    try {
+        payload = {
+            sd_url: new_sd_url,
+        }
+
+        // const full_url = `${g_sd_url}/sd_url/`
+        // console.log('changeSdUrl: payload: ', payload)
+        // let request = await fetch(full_url, {
+        //     method: 'POST',
+        //     headers: {
+        //         Accept: 'application/json',
+        //         'Content-Type': 'application/json',
+        //     },
+        //     body: JSON.stringify(payload),
+        // })
+
+        g_sd_url = new_sd_url
+        // console.log('changeSdUrl: request: ', request)
+    } catch (e) {
+        console.warn(e)
+    }
+}
+
+// function printTheJSONInPrettyFormat(json) {
+//   // var badJSON = document.getElementById('prettyJSONFormat').value;
+//   // var parseJSON = JSON.parse(badJSON);
+//   // var JSONInPrettyFormat = JSON.stringify(json, undefined, 4);
+//   // return
+// }
+async function loadHistory(uniqueDocumentId) {
+    let json = {}
+    try {
+        payload = {
+            uniqueDocumentId: uniqueDocumentId,
+        }
+        json = await py_re.loadHistory(payload)
+        // const full_url = 'http://127.0.0.1:8000/history/load'
+
+        // let request = await fetch(full_url, {
+        //     method: 'POST',
+        //     headers: {
+        //         Accept: 'application/json',
+        //         'Content-Type': 'application/json',
+        //     },
+        //     body: JSON.stringify(payload),
+        // })
+
+        // json = await request.json()
+        // console.log('loadHistory:', json)
+
+        // console.log('loadPromptShortcut: request: ',request)
+    } catch (e) {
+        console.warn(e)
+    }
+
+    return [json['image_paths'], json['metadata_jsons'], json['base64_images']]
+}
+async function loadPromptShortcut() {
+    // console.log('loadPromptShortcut:')
+    let prompt_shortcut_json = {}
+    try {
+        // payload = {}
+
+        // const full_url = 'http://127.0.0.1:8000/prompt_shortcut/load'
+
+        // let request = await fetch(full_url, {
+        //     method: 'POST',
+        //     headers: {
+        //         Accept: 'application/json',
+        //         'Content-Type': 'application/json',
+        //     },
+        //     body: JSON.stringify(payload),
+        // })
+
+        // json = await request.json()
+        prompt_shortcut_json = await py_re.loadPromptShortcut(
+            'prompt_shortcut.json'
+        )
+        console.log('loadPromptShortcut:', prompt_shortcut_json)
+        // console.log('loadPromptShortcut: request: ',request)
+    } catch (e) {
+        console.warn(e)
+        prompt_shortcut_json = {}
+    }
+    return prompt_shortcut_json
+    // return json['prompt_shortcut']
+}
+
+async function savePromptShortcut(prompt_shortcut) {
+    // console.log('loadPromptShortcut:')
+    let json = prompt_shortcut
+    try {
+        // payload = { prompt_shortcut: prompt_shortcut }
+
+        // const full_url = 'http://127.0.0.1:8000/prompt_shortcut/save'
+
+        // let request = await fetch(full_url, {
+        //     method: 'POST',
+        //     headers: {
+        //         Accept: 'application/json',
+        //         'Content-Type': 'application/json',
+        //     },
+        //     body: JSON.stringify(payload),
+        // })
+
+        // json = await request.json()
+        await py_re.savePromptShortcut(json, 'prompt_shortcut.json')
+        console.log('savePromptShortcut:', json)
+        // console.log('loadPromptShortcut: request: ',request)
+    } catch (e) {
+        console.warn(e)
+    }
+
+    return json['prompt_shortcut']
+}
+async function setInpaintMaskWeight(value) {
+    const full_url = `${g_sd_url}/sdapi/v1/options`
+    try {
+        const payload = {
+            inpainting_mask_weight: value,
+        }
+        await fetch(full_url, {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        })
+    } catch (e) {
+        console.warn(e)
+    }
+}
+
+async function requestGetConfig() {
+    console.log('requestGetConfig: ')
+    let json = []
+    const full_url = `${g_sd_url}/config`
+    try {
+        let request = await fetch(full_url)
+        json = await request.json()
+        console.log('models json:')
+        console.dir(json)
+    } catch (e) {
+        console.warn(`issues requesting from ${full_url}`, e)
+    }
+    return json
+}
+async function requestGetOptions() {
+    console.log('requestGetOptions: ')
+    let json = null
+    const full_url = `${g_sd_url}/sdapi/v1/options`
+    try {
+        let request = await fetch(full_url)
+        if (request.status === 404) {
+            return null
+        }
+
+        json = await request.json()
+        console.log('models json:')
+        console.dir(json)
+    } catch (e) {
+        console.warn(`issues requesting from ${full_url}`, e)
+    }
+    return json
+}
+
+async function imageSearch(keywords) {
+    let json = {}
+    const extension_url = py_re.getExtensionUrl()
+
+    const full_url = `${extension_url}/search/image/`
+    try {
+        payload = {
+            keywords: keywords,
+        }
+
+        let request = await fetch(full_url, {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        })
+
+        json = await request.json()
+        console.log('imageSearch:', json)
+
+        return json['images']
+    } catch (e) {
+        console.warn(e)
+    }
+    return []
+}
+
+// async function requestHorde(payload) {
+//     payload = {
+//         prompt: 'string',
+//         params: {
+//             sampler_name: 'k_lms',
+//             toggles: [1, 4],
+//             cfg_scale: 5,
+//             denoising_strength: 0.75,
+//             seed: 'string',
+//             height: 512,
+//             width: 512,
+//             seed_variation: 1,
+//             post_processing: ['GFPGAN'],
+//             karras: false,
+//             tiling: false,
+//             steps: 30,
+//             n: 1,
+//         },
+//         nsfw: false,
+//         trusted_workers: true,
+//         censor_nsfw: false,
+//         workers: ['4c79ab19-8e6c-4054-83b3-773b7ce71ece'],
+//         models: ['stable_diffusion'],
+//         // source_image: 'string',
+//         // source_processing: 'img2img',
+//         // source_mask: 'string',
+//         r2: true,
+//         shared: false,
+//     }
+//     try {
+//         console.log('requestHorde():')
+
+//         const full_url = 'https://stablehorde.net/api/v2/generate/async'
+//         // const full_url = 'https://stablehorde.net/api/v2/generate/sync'
+//         console.log(full_url)
+
+//         let request = await fetch(full_url, {
+//             method: 'POST',
+//             headers: {
+//                 Accept: 'application/json',
+//                 'Content-Type': 'application/json',
+//                 apikey: '0000000000',
+//                 // 'Client-Agent': '4c79ab19-8e6c-4054-83b3-773b7ce71ece',
+//                 'Client-Agent': 'unknown:0:unknown',
+//             },
+//             body: JSON.stringify(payload),
+//         })
+
+//         let json = await request.json()
+//         console.log('requestHorde json:', json)
+
+//         return json
+//     } catch (e) {
+//         console.warn(e)
+//         return {}
+//     }
+// }
+// async function requestHordeCheck(id) {
+//     try {
+//         console.log('requestHordeCheck():')
+//         const base_url = 'https://stablehorde.net/api/v2/generate/check'
+
+//         const full_url = `${base_url}/${id}`
+//         // const full_url = 'https://stablehorde.net/api/v2/generate/sync'
+//         console.log(full_url)
+//         const payload = {}
+//         let request = await fetch(full_url, {
+//             method: 'GET',
+//             headers: {
+//                 Accept: 'application/json',
+//                 'Content-Type': 'application/json',
+//                 // 'Client-Agent': '4c79ab19-8e6c-4054-83b3-773b7ce71ece',
+//                 'Client-Agent': 'unknown:0:unknown',
+//             },
+//         })
+
+//         let json = await request.json()
+//         console.log('requestHordeCheck json:', json)
+
+//         return json
+//     } catch (e) {
+//         console.warn(e)
+//         return {}
+//     }
+// }
+
+// async function requestHordeStatus(id) {
+//     try {
+//         console.log('requestHordeStatus():')
+//         const base_url = 'https://stablehorde.net/api/v2/generate/status'
+
+//         const full_url = `${base_url}/${id}`
+//         // const full_url = 'https://stablehorde.net/api/v2/generate/sync'
+//         console.log(full_url)
+//         const payload = {}
+//         let request = await fetch(full_url, {
+//             method: 'GET',
+//             headers: {
+//                 Accept: 'application/json',
+//                 'Content-Type': 'application/json',
+//                 // 'Client-Agent': '4c79ab19-8e6c-4054-83b3-773b7ce71ece',
+//                 'Client-Agent': 'unknown:0:unknown',
+//             },
+//         })
+
+//         let json = await request.json()
+//         console.log('requestHordeStatus json:', json)
+
+//         return json
+//     } catch (e) {
+//         console.warn(e)
+//         return {}
+//     }
+// }
+
+async function requestExtraSingleImage(payload) {
+    console.log('requestExtraSingleImage(): about to send a fetch request')
+    try {
+        let json = await py_re.extraSingleImageRequest(g_sd_url, payload)
+        console.log('requestExtraSingleImage json:')
+        console.dir(json)
+
+        return json
+    } catch (e) {
+        console.warn(e)
+        return {}
+    }
+}
+
+async function requestGetUpscalers() {
+    console.log('requestGetUpscalers: ')
+    let json = []
+    const full_url = `${g_sd_url}/sdapi/v1/upscalers`
+    try {
+        let request = await fetch(full_url)
+        json = await request.json()
+        console.log('upscalers json:')
+        console.dir(json)
+    } catch (e) {
+        console.warn(`issues requesting from ${full_url}`, e)
+    }
+    return json
+}
+
+//REFACTOR: reuse the same code for (requestControlNetTxt2Img,requestControlNetImg2Img)
+async function requestControlNetTxt2Img(plugin_settings) {
+    console.log('requestControlNetTxt2Img: ')
+
+    // const full_url = `${g_sd_url}/controlnet/txt2img`
+    const full_url = `${g_sd_url}/sdapi/v1/txt2img`
+    // debugger
+    const control_net_settings =
+        control_net.mapPluginSettingsToControlNet(plugin_settings)
+    let control_networks = []
+    // let active_control_networks = 0
+    for (let index = 0; index < g_controlnet_max_models; index++) {
+        if (!control_net.getEnableControlNet(index)) {
+            control_networks[index] = false
+            continue
+        }
+        control_networks[index] = true
+        // debugger
+        if (!control_net_settings['controlnet_units'][index]['input_image']) {
+            app.showAlert('you need to add a valid ControlNet input image')
+            throw 'you need to add a valid ControlNet input image'
+        }
+
+        if (!control_net_settings['controlnet_units'][index]['module']) {
+            app.showAlert('you need to select a valid ControlNet Module')
+            throw 'you need to select a valid ControlNet Module'
+        }
+        if (
+            !control_net_settings['controlnet_units'][index]['model'] &&
+            !control_net.getModuleDetail()[
+                control_net_settings['controlnet_units'][index]['module']
+            ].model_free
+        ) {
+            app.showAlert('you need to select a valid ControlNet Model')
+            throw 'you need to select a valid ControlNet Model'
+        }
+        // active_control_networks++
+    }
+
+    let request = await fetch(full_url, {
+        method: 'POST',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(control_net_settings),
+    })
+
+    let json = await request.json()
+    console.log('json:', json)
+
+    //update the mask in controlNet tab
+    const numOfImages = json['images'].length
+    let numberOfAnnotations =
+        numOfImages - g_generation_session.last_settings.batch_size
+    if (numberOfAnnotations < 0) numberOfAnnotations = 0
+
+    const base64_mask = json['images'].slice(numOfImages - numberOfAnnotations)
+
+    let mask_index = 0
+
+    for (let index = 0; index < control_networks.length; index++) {
+        if (
+            control_networks[index] == false ||
+            mask_index >= numberOfAnnotations
+        )
+            continue
+        html_manip.setControlMaskSrc(
+            base64ToBase64Url(base64_mask[mask_index]),
+            index
+        )
+        g_generation_session.controlNetMask[index] = base64_mask[mask_index]
+        mask_index++
+    }
+    // g_generation_session.controlNetMask = base64_mask
+
+    const standard_response = await py_re.convertToStandardResponse(
+        control_net_settings,
+        json['images'].slice(0, numOfImages - numberOfAnnotations),
+        plugin_settings['uniqueDocumentId']
+    )
+    console.log('standard_response:', standard_response)
+
+    return standard_response
+}
+
+//REFACTOR: reuse the same code for (requestControlNetTxt2Img,requestControlNetImg2Img)
+async function requestControlNetImg2Img(plugin_settings) {
+    console.log('requestControlNetImg2Img: ')
+    // const full_url = 'http://127.0.0.1:8000/swapModel'
+
+    // const full_url = `${g_sd_url}/controlnet/img2img`
+    const full_url = `${g_sd_url}/sdapi/v1/img2img`
+    const control_net_settings =
+        control_net.mapPluginSettingsToControlNet(plugin_settings)
+
+    // let control_networks = 0
+    let control_networks = []
+    for (let index = 0; index < g_controlnet_max_models; index++) {
+        if (!control_net.getEnableControlNet(index)) {
+            control_networks[index] = false
+            continue
+        }
+        control_networks[index] = true
+        if (!control_net_settings['controlnet_units'][index]['input_image']) {
+            app.showAlert('you need to add a valid ControlNet input image')
+            throw 'you need to add a valid ControlNet input image'
+        }
+
+        if (!control_net_settings['controlnet_units'][index]['module']) {
+            app.showAlert('you need to select a valid ControlNet Module')
+            throw 'you need to select a valid ControlNet Module'
+        }
+        if (
+            !control_net_settings['controlnet_units'][index]['model'] &&
+            !control_net.getModuleDetail()[
+                control_net_settings['controlnet_units'][index]['module']
+            ].model_free
+        ) {
+            app.showAlert('you need to select a valid ControlNet Model')
+            throw 'you need to select a valid ControlNet Model'
+        }
+    }
+
+    let request = await fetch(full_url, {
+        method: 'POST',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(control_net_settings),
+        // body: JSON.stringify(payload),
+    })
+
+    let json = await request.json()
+    console.log('json:', json)
+
+    //update the mask in controlNet tab
+    const numOfImages = json['images'].length
+    let numberOfAnnotations =
+        numOfImages - g_generation_session.last_settings.batch_size
+    if (numberOfAnnotations < 0) numberOfAnnotations = 0
+
+    // To fix a bug: when Ultimate SD Upscale is active and running, the detection maps won’t be retrieved.
+    // So set its value to 0 to avoid the result images being loaded in the annotation map interface.
+    if (
+        scripts.script_store.is_active &&
+        scripts.script_store.selected_script_name !== 'None' &&
+        scripts.script_store.is_selected_script_available
+    ) {
+        numberOfAnnotations = 0
+    }
+    const base64_mask = json['images'].slice(numOfImages - numberOfAnnotations)
+
+    let mask_index = 0
+    for (let index = 0; index < control_networks.length; index++) {
+        if (
+            control_networks[index] == false ||
+            mask_index >= numberOfAnnotations
+        )
+            continue
+        html_manip.setControlMaskSrc(
+            base64ToBase64Url(base64_mask[mask_index]),
+            index
+        )
+        g_generation_session.controlNetMask[index] = base64_mask[mask_index]
+        mask_index++
+    }
+
+    // g_generation_session.controlNetMask = base64_mask
+
+    const standard_response = await py_re.convertToStandardResponse(
+        control_net_settings,
+        json['images'].slice(0, numOfImages - numberOfAnnotations),
+        plugin_settings['uniqueDocumentId']
+    )
+    console.log('standard_response:', standard_response)
+
+    // //get all images except last because it's the mask
+    // for (const image of json['images'].slice(0, -1)) {
+    //     await io.IO.base64ToLayer(image)
+    // }
+
+    return standard_response
+}
+
+async function isWebuiRunning() {
+    console.log('isWebuiRunning: ')
+    let json = []
+    const full_url = `${g_sd_url}/user`
+    try {
+        let request = await fetch(full_url)
+        json = await request.json()
+        console.log('json:')
+        console.dir(json)
+    } catch (e) {
+        console.warn(`issues requesting from ${full_url}`, e)
+        return false
+    }
+    return true
+}
+async function requestLoraModels() {
+    const extension_url = py_re.getExtensionUrl()
+    const full_url = `${extension_url}/lora/list`
+    const lora_models = await api.requestGet(full_url)
+    return lora_models
+}
+module.exports = {
+    requestTxt2Img,
+    requestImg2Img,
+    getInitImage,
+    requestProgress,
+    requestGetModels,
+    requestSwapModel,
+    requestInterrupt,
+    requestGetSamplers,
+    getVersionRequest,
+    changeSdUrl,
+    loadPromptShortcut,
+    savePromptShortcut,
+    loadHistory,
+    setInpaintMaskWeight,
+    requestGetConfig,
+    requestGetOptions,
+    imageSearch,
+    requestSavePng,
+    // requestHorde,
+    // requestHordeCheck,
+    // requestHordeStatus,
+    requestExtraSingleImage,
+    requestGetUpscalers,
+    requestControlNetTxt2Img,
+    requestControlNetImg2Img,
+    isWebuiRunning,
+    requestLoraModels,
+}

Auto-Photoshop-StableDiffusion-Plugin/selection.js

@@ -0,0 +1,167 @@
+const psapi = require('./psapi')
+const html_manip = require('./utility/html_manip')
+function finalWidthHeight(
+    selectionWidth,
+    selectionHeight,
+    minWidth,
+    minHeight
+) {
+    // const minWidth = 512
+    // const minHeight = 512
+
+    // const selectionWidth = 256
+    // const selectionHeight = 1000
+
+    let finalWidth = 0
+    let finalHeight = 0
+
+    if (selectionWidth <= selectionHeight) {
+        //do operation on the smaller dimension
+        const scaleRatio = selectionWidth / minWidth
+
+        finalWidth = minWidth
+        finalHeight = selectionHeight / scaleRatio
+    } else {
+        const scaleRatio = selectionHeight / minHeight
+
+        finalHeight = minHeight
+        finalWidth = selectionWidth / scaleRatio
+    }
+    return [finalWidth, finalHeight]
+}
+
+async function selectionToFinalWidthHeight() {
+    // const { getSelectionInfoExe } = require('./psapi')
+    try {
+        const selectionInfo = await psapi.getSelectionInfoExe()
+        const [finalWidth, finalHeight] = finalWidthHeight(
+            selectionInfo.width,
+            selectionInfo.height,
+            512,
+            512
+        )
+
+        return [
+            parseInt(finalWidth),
+            parseInt(finalHeight),
+            selectionInfo.width,
+            selectionInfo.height,
+        ]
+    } catch (e) {
+        console.warn('you need a rectangular selection', e)
+    }
+}
+
+async function selectBoundingBox() {
+    let l = await app.activeDocument.activeLayers[0]
+    let bounds = await l.boundsNoEffects
+    let selectionInfo = convertSelectionObjectToSelectionInfo(bounds)
+    await psapi.reSelectMarqueeExe(selectionInfo)
+    return selectionInfo
+}
+function convertSelectionObjectToSelectionInfo(selection_obj) {
+    let selection_info = {
+        left: selection_obj._left,
+        right: selection_obj._right,
+        bottom: selection_obj._bottom,
+        top: selection_obj._top,
+        height: selection_obj._bottom - selection_obj._top,
+        width: selection_obj._right - selection_obj._left,
+    }
+    return selection_info
+}
+
+const SelectionInfoDesc = () => ({
+    _obj: 'get',
+    _target: [
+        {
+            _property: 'selection',
+        },
+        {
+            _ref: 'document',
+            _id: app.activeDocument._id,
+        },
+    ],
+    _options: {
+        dialogOptions: 'dontDisplay',
+    },
+})
+class Selection {
+    static async getSelectionInfoExe() {
+        //return a selectionInfo object or undefined
+        try {
+            const selection = await executeAsModal(async () => {
+                const result = await batchPlay([SelectionInfoDesc()], {
+                    synchronousExecution: true,
+                    modalBehavior: 'execute',
+                })
+
+                return result[0]?.selection
+            })
+
+            if (this.isSelectionValid(selection)) {
+                let selection_info = {
+                    left: selection.left._value,
+                    right: selection.right._value,
+                    bottom: selection.bottom._value,
+                    top: selection.top._value,
+                    height: selection.bottom._value - selection.top._value,
+                    width: selection.right._value - selection.left._value,
+                }
+                // console.dir({selection_info})
+                return selection_info
+            }
+        } catch (e) {
+            console.warn('selection info error', e)
+        }
+    }
+
+    static isSelectionValid(selection) {
+        console.warn(
+            'isSelectionValid is deprecated use selection.isSelectionValid instead'
+        )
+        if (
+            selection && // check if the selection is defined
+            selection.hasOwnProperty('left') &&
+            selection.hasOwnProperty('right') &&
+            selection.hasOwnProperty('top') &&
+            selection.hasOwnProperty('bottom')
+        ) {
+            return true
+        }
+
+        return false
+    }
+    static reselectArea(selection_info) {}
+    static isSameSelection(selection_info_1, selection_info_2) {}
+    static async getImageToSelectionDifference() {
+        const selectionInfo = await psapi.getSelectionInfoExe()
+
+        const width = html_manip.getWidth()
+        const height = html_manip.getHeight()
+        const scale_info_str = `${parseInt(width)}x${parseInt(
+            height
+        )} => ${parseInt(selectionInfo.width)}x${parseInt(
+            selectionInfo.height
+        )} `
+        let ratio =
+            (width * height) / (selectionInfo.width * selectionInfo.height)
+
+        // const arrow = percentage >= 1 ? '↑' : '↓'
+        // percentage = percentage >= 1 ? percentage : 1 / percentage
+
+        // const percentage_str = `${arrow}X${percentage.toFixed(2)}`
+
+        // console.log('scale_info_str: ', scale_info_str)
+        // console.log('percentage_str: ', percentage_str)
+        return ratio
+    }
+    static {}
+}
+module.exports = {
+    finalWidthHeight,
+    selectionToFinalWidthHeight,
+    selectBoundingBox,
+    convertSelectionObjectToSelectionInfo,
+    Selection,
+}

Auto-Photoshop-StableDiffusion-Plugin/server/python_server/control_net.py

@@ -0,0 +1,65 @@
+
+# controlnet original + txt2img
+import requests
+import cv2
+import numpy as np
+from base64 import b64encode , b64decode
+from PIL import Image
+import io
+
+def readImage(path):
+    img = cv2.imread(path)
+    retval, buffer = cv2.imencode('.jpg', img)
+    b64img = b64encode(buffer).decode("utf-8")
+    return b64img
+
+def readb64(uri):
+   nparr = np.fromstring(b64decode(uri), np.uint8)
+   img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+   return img
+
+b64img = readImage("output_image.png")
+
+class controlnetRequest():
+    def __init__(self, prompt):
+        self.url = "http://127.0.0.1:7860/controlnet/txt2img" #openpose
+        self.body = {
+            "prompt": prompt,
+            "negative_prompt": "",
+            "seed": -1,
+            "subseed": -1,
+            "subseed_strength": 0,
+            "batch_size": 1,
+            "n_iter": 1,
+            "steps": 30,
+            "cfg_scale": 14,
+            "width": 512,
+            "height": 512,
+            "restore_faces": True,
+            "eta": 0,
+            "sampler_index": "DDIM",
+            "controlnet_model": "Test_ziva",
+            "controlnet_input_image": [b64img],
+            "controlnet_module": 'depth',
+            "ControlNet Weight": 1,
+            "controlnet_model": 'control_sd15_depth [fef5e48e]',
+            "controlnet_guidance": 1
+        }
+
+    def sendRequest(self):
+        # print(self.simple_txt2img)
+        r = requests.post(self.url, json=self.body)
+        print(r)
+        return r.json()
+ 
+js = controlnetRequest("clothed busty bird").sendRequest()
+
+
+for x,i in enumerate(js['images']):
+    image = Image.open(io.BytesIO(b64decode(i.split(",",1)[0])))
+    image.save(str(x)+'output.png')
+
+
+
+len(js['images'])
+print(js)

Auto-Photoshop-StableDiffusion-Plugin/server/python_server/img2imgapi.py

@@ -0,0 +1,163 @@
+import json
+import requests
+import io
+import base64
+from PIL import Image, PngImagePlugin
+# from serverMain import sd_url
+import asyncio
+import httpx
+
+
+from io import BytesIO
+import prompt_shortcut
+
+# Convert Image to Base64 
+def img_2_b64(image):
+    buff = BytesIO()
+    image.save(buff, format="PNG")
+    img_byte = base64.b64encode(buff.getvalue())
+    img_str = img_byte.decode("utf-8")
+    return img_str
+
+import time
+import serverHelper
+import metadata_to_json
+
+def b64_2_img(base64_image):
+     image = Image.open(io.BytesIO(base64.b64decode(base64_image.split(",",1)[0])))
+     return image
+
+def reserveBorderPixels(img,dilation_img):
+    pixels = img.load() # this is not a list, nor is it list()'able
+    width, height = img.size
+    dilation_pixels =  dilation_img.load()
+    all_pixels = []
+    depth = 20 # five pixel depth
+    for x in range(width):
+        for d in range(depth): 
+            dilation_pixels[x,d] =  pixels[x, d]
+            dilation_pixels[x,height-(d+1)] =  pixels[x, height-(d+1)]
+        # all_pixels.append(cpixel)
+    for y in range(height):
+        for d in range(depth): 
+            dilation_pixels[d,y] =  pixels[d,y] # d = 0
+            dilation_pixels[width-(d+1),y] =  pixels[width-(d+1), y]
+    return dilation_img
+        
+def maskExpansion(mask_img,mask_expansion):
+     #only if image exist then try to open it
+    
+        
+        # init_img_mask = Image.open(f"{init_img_dir}/{init_img_mask_name}")
+        
+        # if(payload['use_sharp_mask'] == False):# use blurry mask 
+        iteration = mask_expansion
+        dilated_img = applyDilation(mask_img,iteration)
+        mask_with_border = reserveBorderPixels(mask_img,dilated_img)
+        mask_with_border = mask_with_border.filter(ImageFilter.GaussianBlur(radius = 10))
+        return mask_with_border
+        
+async def base64ToPng(base64_image,image_path):
+    base64_img_bytes = base64_image.encode('utf-8')
+    with open(image_path, 'wb') as file_to_save:
+        decoded_image_data = base64.decodebytes(base64_img_bytes)
+        file_to_save.write(decoded_image_data)    
+        
+        
+
+
+from PIL import Image, ImageFilter
+def applyDilation(img,iteration=20,max_filter=3):
+    # img = Image.open("test_image_2.png")
+    dilation_img = img.copy()
+    # for i in range(20):
+    #     dilation_img = dilation_img.filter(ImageFilter.MaxFilter(3))
+    for i in range(iteration):
+        dilation_img = dilation_img.filter(ImageFilter.MaxFilter(max_filter))
+    return dilation_img
+
+
+
+async def img2ImgRequest(sd_url,payload):
+    # init_img = Image.open(r"C:/Users/abdul/Desktop/photoshop_plugins/my_plugin_1/server/python_server/output- 1670544300.95411.png") 
+    print("payload debug:",payload)
+    
+    if(payload['use_prompt_shortcut']): # use edit prompt
+        #edit prompt, replaceShortcut(prompt)
+        prompt_shortcut_dict = prompt_shortcut.load()
+        prompt_shortcut_dict.update(payload["prompt_shortcut_ui_dict"])
+        payload['prompt'] = prompt_shortcut.replaceShortcut(payload['prompt'],prompt_shortcut_dict)
+        # edit negative prompt, replaceShortcut(negative_prompt)
+        payload['negative_prompt'] = prompt_shortcut.replaceShortcut(payload['negative_prompt'],prompt_shortcut_dict)
+        
+    init_img_dir = "./init_images"
+    init_img_name = payload['init_image_name']
+    init_img = Image.open(f"{init_img_dir}/{init_img_name}")
+    init_img_str = img_2_b64(init_img) 
+    payload['init_images'] = [init_img_str]
+
+    # mask
+
+    init_img_mask_name = payload.get('init_image_mask_name',"")
+    
+
+    #only if image exist then try to open it
+    if(len(init_img_mask_name) > 0):
+        init_img_mask = Image.open(f"{init_img_dir}/{init_img_mask_name}")
+        
+        if(payload['use_sharp_mask'] == False):# use blurry mask 
+            iteration = payload['mask_expansion']
+            init_img_mask = applyDilation(init_img_mask,iteration)
+
+        init_img_mask_str = img_2_b64(init_img_mask) 
+        payload['mask'] = init_img_mask_str #there is only one mask, unlike 'init_images' which is of type array
+
+
+    # payload = { 
+    #     "prompt": "cute dog",
+    #     "steps": 10,
+    #     "init_images":[init_img_str],
+    #     "n_iter":3
+    # }
+    # print("payload:",payload)
+    print(type(init_img_str))
+    #request the images to be generated
+    async with httpx.AsyncClient() as client:
+        response = await client.post(url=f'{sd_url}/sdapi/v1/img2img', json=payload, timeout=None)
+
+        r = response.json()
+
+        #create a directory to store the images at
+        # dirName = f'{time.time()}'
+        # dir_fullpath,dirName = serverHelper.makeDirPathName()
+        uniqueDocumentId = payload['uniqueDocumentId']
+        dir_fullpath,dirName = serverHelper.getUniqueDocumentDirPathName(uniqueDocumentId)
+        serverHelper.createFolder(dir_fullpath)
+        image_paths = []
+        metadata = []
+        images_info = []
+        #for each image store the prompt and settings in the meta data
+        for i in r['images']:
+            image = Image.open(io.BytesIO(base64.b64decode(i.split(",",1)[0])))
+
+            png_payload = {
+                "image": "data:image/png;base64," + i
+            }
+            response2 = await client.post(url=f'{sd_url}/sdapi/v1/png-info', json=png_payload, timeout=None)
+            pnginfo = PngImagePlugin.PngInfo()
+            pnginfo.add_text("parameters", response2.json().get("info"))
+            image_name = f'output- {time.time()}.png'
+            image_path = f'output/{dirName}/{image_name}'
+            image_paths.append(image_path)
+            image.save(f'./{image_path}', pnginfo=pnginfo)
+
+            metadata_info = response2.json().get("info")
+            metadata_json = metadata_to_json.convertMetadataToJson(metadata_info)
+            metadata.append(metadata_json)
+            images_info.append({"base64":i,"path":image_path})
+            print("metadata_json: ", metadata_json)   
+        
+        return dirName,images_info,metadata
+
+if __name__=="__main__":
+    img2ImgRequest()

Auto-Photoshop-StableDiffusion-Plugin/server/python_server/init_images/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

Auto-Photoshop-StableDiffusion-Plugin/server/python_server/metadata_to_json.py

@@ -0,0 +1,78 @@
+import os
+from pathlib import Path
+from PIL import Image
+import json
+
+import serverHelper
+# metadata_str = 'cute cat\nSteps: 20, Sampler: Euler a, CFG scale: 7.0, Seed: 2253354038, Size: 512x512, Model hash: 3e16efc8, Seed resize from: -1x-1, Denoising strength: 0, Conditional mask weight: 1.0'
+def convertMetadataToJson(metadata_str):
+    print(metadata_str)
+    last_new_line_index = metadata_str.rindex('\n')
+    prompt = metadata_str[:last_new_line_index]
+    other_settings = metadata_str[last_new_line_index+1:] 
+
+    print("prompt:", prompt)
+    print("other_settings:", other_settings)
+    sub_settings = other_settings.split(",")
+    print("sub_settings: ",sub_settings)
+
+    settings_dict = {}
+    settings_dict['prompt'] = prompt
+
+    for setting in sub_settings:
+        [key,value]= setting.split(":")
+        key =  key.lstrip(' ')
+        value =  value.lstrip(' ')
+        settings_dict[key] = value
+    import json
+    settings_json = json.dumps(settings_dict)
+    print("settings_dict: ",settings_dict)
+    print("settings_json ",settings_json)
+    return settings_json
+
+
+
+
+def getMetadataFromPng(image_path):
+    # image_path = "./output/5c42fd2a-6708-45e2-b282-2e9f3894368e/output- 1672476035.4888158.png"
+    # image_path = "C:/Users/abdul/Desktop/auto-photoshop/Auto-Photoshop-StableDiffusion-Plugin/server/python_server/output/5c42fd2a-6708-45e2-b282-2e9f3894368e/output- 1672476035.4888158.png"
+    im = Image.open(image_path) 
+    # im.load()  # Needed only for .png EXIF data (see citation above)
+    # print(im.info['parameters'])
+    metadata_string = im.info['parameters']
+    metadata_json_string = convertMetadataToJson(metadata_string)
+    metadata_dict = json.loads(metadata_json_string)
+    print("metadata_dict: ", metadata_dict)
+    # print(im.info['meta_to_read'])
+    return metadata_dict
+
+
+def createMetadataJsonFileIfNotExist(image_path):
+    
+    # image_name = os.path.splitext(image_path)
+    image_name = Path(image_path).stem
+    # parent_dir_path = Path(image_path)
+    # parent_dir_path = image_path.split(image_name)[0]
+    # os.path.join()
+    head = os.path.split(image_path)[0]
+    json_file_tail = f'{image_name}.json'
+    json_full_path = os.path.join(head,json_file_tail)
+    print("image_name: ",image_name)
+    print("json_full_path: ",json_full_path)
+    isExist = os.path.exists(json_full_path)
+    if(isExist):
+        #read metadata from json
+        metadata_dict = serverHelper.readJson(json_full_path)
+        
+    else:
+        #read metadata from image
+        #save the metadata to a json file
+        metadata_dict = getMetadataFromPng(image_path)
+        serverHelper.writeJson(json_full_path,metadata_dict)
+    return metadata_dict
+        
+
+if __name__ == "__main__":
+    image_path = "C:/Users/abdul/Desktop/auto-photoshop/Auto-Photoshop-StableDiffusion-Plugin/server/python_server/output/5c42fd2a-6708-45e2-b282-2e9f3894368e/output- 1672476035.4888158.png"
+    # getMetadataFromPng(image_path)
+    createMetadataJsonFileIfNotExist(image_path)

Auto-Photoshop-StableDiffusion-Plugin/server/python_server/output/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

Auto-Photoshop-StableDiffusion-Plugin/server/python_server/prompt_shortcut - Copy.json

@@ -0,0 +1,12 @@
+{
+    "painterly_style_1": "A full portrait of a beautiful post apocalyptic offworld arctic explorer, intricate, elegant, highly detailed, digital painting, artstation, concept art, smooth, sharp focus, illustration",
+    "ugly": " ((((ugly)))), (((duplicate))), ((morbid)), ((mutilated)), out of frame, extra fingers, mutated hands, ((poorly drawn hands)), ((poorly drawn face)), (((mutation))), (((deformed))), ((ugly)), blurry, ((bad anatomy)), (((bad proportions))), ((extra limbs)), cloned face, (((disfigured))), out of frame, ugly, extra limbs, (bad anatomy), gross proportions, (malformed limbs), ((missing arms)), ((missing legs)), (((extra arms))), (((extra legs))), mutated hands, (fused fingers), (too many fingers), (((long neck)))",
+    "art_style": "(SPACE1999:1.0),(dreamlikeart style:1.0), ( redshift style:1.0), (analog style:1.2), (studio_ghibli_anime_style style:0.7), (copeseethemald style:0.8)",
+    "woman_style": "woman, 1girls, solo, detailed face, lips, realistic pupils, closeup, centered,  standing, centered, skin pores, subsurface scattering, detailed skin",
+    "environment_style": "detailed background, items, realistic proportions, blushing, masterpiece, best quality, realistic, hyperrealistic, sharp focus, absurdres, good anatomy",
+    "uniform_style": "space uniform, red, smooth, black belt, black boots",
+    "man_style": "man, solo, detailed face, lips, realistic pupils, closeup, centered,  standing, centered, skin pores, subsurface scattering, detailed skin",
+    "neg_person": "(glossy:1.0), freckles, nipples, small waist, lowres, large head, long neck, blurry, bad anatomy, bad hands, extra limbs, extra hands, mutated hands, mutated fingers, missing hand, missing finger, text, error, missing fingers, extra digit, fewer digits,",
+    "neg_general": "cropped, worst quality, low quality, normal quality, jpeg artifacts, text, signature, watermark, artist name, logo,",
+    "nova_green": "[Julianne Hough:Jaime King:0.5]"
+}

Auto-Photoshop-StableDiffusion-Plugin/server/python_server/prompt_shortcut.py

@@ -0,0 +1,61 @@
+import re
+import json
+prompt_shortcut_dict ={}
+
+
+def readToJson():
+    return load()
+
+def writeToJson(file_name,data_dict):
+    with open(file_name, "w") as outfile:
+        json.dump(data_dict, outfile,indent=4)
+
+
+def load(): 
+    global prompt_shortcut_dict
+    try:
+        with open('prompt_shortcut.json') as f_obj:
+            data = json.load(f_obj)
+            prompt_shortcut_dict = data
+            print(data)
+    except IOError:
+        print("prompt_shortcut.json is not found")
+    return prompt_shortcut_dict
+def find_words_inside_braces(string):
+    result = ""
+    pattern ="\{(.*?)\}"
+    keywords = []
+    for match in re.findall(pattern, string):
+        keywords.append(match)
+        result += match
+    return keywords
+
+# text = "a beautiful girl holding a cute cat {style_1} on sunny day"
+# text = "a beautiful girl holding a cute cat {    style_1 } on sunny day"
+text = "a beautiful girl{    }, {char1}, {painterly_style} holding a cute cat {    style_1 } on sunny day"
+# text = "a beautiful girl {char1 } holding a cute cat on sunny day"
+
+
+
+def replaceShortcut(text,prompt_shortcut_dict):
+    raw_keywords = find_words_inside_braces(text)
+    strip_keywords = list(map(lambda s: s.strip(),raw_keywords))
+
+    original_substrings = list(map(lambda s: '{'+s+'}',raw_keywords)) 
+
+    print("raw_keywords: ", raw_keywords)
+    print("strip_keywords: ", strip_keywords)
+    print("original_substrings: ",original_substrings)
+    # print ("text:",text)
+
+    for i, word in enumerate(strip_keywords):
+        # word = word.strip()
+        print("word: ",word)
+        if len(word) > 0 and word in prompt_shortcut_dict:
+            prompt = prompt_shortcut_dict[word]
+            print("prompt: ",prompt)
+            text = text.replace(original_substrings[i],prompt)
+        # else:
+            # text = text.replace(word,word.strip())
+    print ("final text: ",text) 
+    return text

Auto-Photoshop-StableDiffusion-Plugin/server/python_server/search.py

@@ -0,0 +1,24 @@
+from itertools import islice
+
+try:
+    from duckduckgo_search import DDGS
+except ImportError:
+    raise ImportError(
+        "duckduckgo_search is required to image search. Please install it with `pip install --upgrade duckduckgo_search`."
+    )
+
+
+async def imageSearch(keywords="cute cats"):
+    with DDGS() as ddgs:
+        return [x for x in islice(ddgs.images(keywords), 30)]
+
+
+if __name__ == "__main__":
+
+    async def main():
+        result = await imageSearch()
+        print(result)
+
+    import asyncio
+
+    asyncio.run(main())

Auto-Photoshop-StableDiffusion-Plugin/server/python_server/serverHelper.py

@@ -0,0 +1,64 @@
+import time
+import os
+import datetime
+import uuid
+import json
+
+# this function should be used whenever we need to write to json file
+def writeJson(file_name,data_dict):
+    with open(file_name, 'w', encoding='utf-8') as outfile:
+        json.dump(data_dict, outfile, ensure_ascii=False, indent=4)
+        
+    
+    
+
+# this function should be used whenever we need to read from json file
+def readJson(file_name): 
+    data_dict = {}
+    try:
+        with open(file_name) as f_obj:
+            data_dict = json.load(f_obj)
+            
+            print("readJson: data_dict: ", data_dict)
+    except IOError:
+        print(f"{file_name} is not found")
+    return data_dict
+
+def createFolder(fullpath):
+    print("fullpath:",fullpath)
+    
+    if not os.path.exists(fullpath):
+        os.mkdir(fullpath)
+#create string dir path name based on the current time
+def makeDirPathName():
+    # dirName = f'{time.time()}'
+    currentDirPath = os.getcwd()
+    now = datetime.datetime.now()
+    daily_folder = now.strftime("%Y-%m-%d")
+    output_path = os.path.join(currentDirPath,"output")
+    fullpath = os.path.join(output_path,daily_folder)
+    # fullpath = os.path.join(currentDirPath,dirName)
+    return fullpath,daily_folder
+
+#create string dir path name based on the uniqueDocumentId
+def getUniqueDocumentDirPathName(uniqueDocumentId):
+    
+    currentDirPath = os.getcwd()
+    output_path = os.path.join(currentDirPath,"output")
+    fullpath = os.path.join(output_path,uniqueDocumentId)
+
+    return fullpath,uniqueDocumentId
+
+def makeUniqueID():
+    myuuid = uuid.uuid4()
+    print('Your UUID is: ' + str(myuuid))
+    return myuuid
+
+
+if __name__ == "__main__":
+    # currentDirPath = os.getcwd()
+    # dirName = f'{time.time()}'
+    # fullpath = os.path.join(currentDirPath,dirName)
+    # createFolder(fullpath)
+    id = makeUniqueID()
+    print("id: ",id)

Auto-Photoshop-StableDiffusion-Plugin/server/python_server/serverMain.py

@@ -0,0 +1,495 @@
+
+import json
+import requests
+import io
+import base64
+from PIL import Image, PngImagePlugin
+import asyncio
+import httpx
+
+
+import os
+import time
+import serverHelper
+import prompt_shortcut
+import metadata_to_json
+import search
+sd_url = os.environ.get('SD_URL', 'http://127.0.0.1:7860')
+
+
+
+
+async def txt2ImgRequest(payload):
+    # payload = { 
+    #     "prompt": "cute cat, kitten",
+    #     "steps": 10
+    # }
+    print("payload: ",payload)
+    
+    if(payload['use_prompt_shortcut']): # use edit prompt
+        #edit prompt, replaceShortcut(prompt)
+        prompt_shortcut_dict = prompt_shortcut.load()
+        prompt_shortcut_dict.update(payload["prompt_shortcut_ui_dict"])
+        payload['prompt'] = prompt_shortcut.replaceShortcut(payload['prompt'],prompt_shortcut_dict)
+        # edit negative prompt, replaceShortcut(negative_prompt)
+        payload['negative_prompt'] = prompt_shortcut.replaceShortcut(payload['negative_prompt'],prompt_shortcut_dict)
+        
+    
+    #request the images to be generated
+    request_path = "/sdapi/v1/txt2img"
+    
+    async with httpx.AsyncClient() as client:
+        response = await client.post(url=f'{sd_url}/sdapi/v1/txt2img', json=payload, timeout=None)
+        r = response.json()
+
+        #create a directory to store the images at
+        # dirName = f'{time.time()}'
+        # dir_fullpath,dirName = serverHelper.makeDirPathName()
+        uniqueDocumentId = payload['uniqueDocumentId']
+        dir_fullpath,dirName = serverHelper.getUniqueDocumentDirPathName(uniqueDocumentId)
+        serverHelper.createFolder(dir_fullpath)
+        image_paths = []
+        #for each image store the prompt and settings in the meta data
+        metadata = []
+        images_info = []
+        for i in r['images']:
+            image = Image.open(io.BytesIO(base64.b64decode(i.split(",",1)[0])))
+
+            png_payload = {
+                "image": "data:image/png;base64," + i
+            }
+            response2 = await client.post(url=f'{sd_url}/sdapi/v1/png-info', json=png_payload)
+            pnginfo = PngImagePlugin.PngInfo()
+            pnginfo.add_text("parameters", response2.json().get("info"))
+            image_name = f'output- {time.time()}.png'
+            
+            image_path = f'output/{dirName}/{image_name}'
+            image_paths.append(image_path)
+            image.save(f'./{image_path}', pnginfo=pnginfo)
+            
+            metadata_info = response2.json().get("info")
+            metadata_json = metadata_to_json.convertMetadataToJson(metadata_info)
+            metadata.append(metadata_json)
+            images_info.append({"base64":i,"path":image_path})
+            print("metadata_json: ", metadata_json)
+        
+        
+        return dirName,images_info,metadata
+
+import base64
+from io import BytesIO
+
+
+def img_2_b64(image):
+    buff = BytesIO()
+    image.save(buff, format="PNG")
+    img_byte = base64.b64encode(buff.getvalue())
+    img_str = img_byte.decode("utf-8")
+    return img_str
+
+
+from typing import Union
+
+from fastapi import FastAPI
+from fastapi import APIRouter, Request
+
+
+
+router = APIRouter()
+
+
+@router.get("/")
+def read_root():
+    return {"Hello": "World"}
+
+
+@router.get("/version")
+def getVersion():
+    manifest_dir = "..\..\manifest.json"
+    
+    manifest = {'version': '0.0.0'}
+    version = "0.0.0"
+    try:
+
+        with open(manifest_dir, 'r') as f:
+            manifest = json.load(f)
+            version = manifest['version']
+    except:
+        print("couldn't read the manifest.json")
+    return {"version": f"v{version}"}
+
+
+
+
+
+
+# @router.post("/txt2img/")
+# async def txt2ImgHandle(payload:Payload):
+#     print("txt2ImgHandle: \n")
+#     txt2ImgRequest(payload)
+#     return {"prompt":payload.prompt,"images": ""}
+
+
+from fastapi import Request, Response
+import img2imgapi
+
+
+
+
+
+
+@router.post("/sd_url/")
+async def changeSdUrl(request:Request):
+    global sd_url
+    try:
+
+        payload = await request.json()
+        print("changeSdUrl: payload:",payload)
+        print(f"change sd url from {sd_url} to {payload['sd_url']} \n")
+        sd_url = payload['sd_url']
+    except:
+        print("error occurred in changeSdUrl()")
+        #  response.body = resp.content
+        # return {}
+    return {"sd_url":sd_url}
+
+
+
+
+
+
+
+
+
+@router.post("/txt2img/")
+async def txt2ImgHandle(request:Request):
+    print("txt2ImgHandle: \n")
+    payload = await request.json() 
+    dir_name,images_info,metadata, = await txt2ImgRequest(payload)
+    # return {"prompt":payload.prompt,"images": ""}
+    return {"payload": payload,"dir_name": dir_name,"images_info":images_info,"metadata":metadata}
+
+@router.post("/img2img/")
+async def img2ImgHandle(request:Request):
+    print("img2ImgHandle: \n")
+    payload = await request.json() 
+    dir_name,images_info,metadata = await img2imgapi.img2ImgRequest(sd_url,payload)
+    # return {"prompt":payload.prompt,"images": ""}
+    return {"payload": payload,"dir_name": dir_name,"images_info":images_info,"metadata":metadata}
+
+
+
+
+
+
+@router.post("/getInitImage/")
+async def getInitImageHandle(request:Request):
+    print("getInitImageHandle: \n")
+    payload = await request.json() 
+    print("payload:",payload)
+    init_img_dir = "./init_images"
+    init_img_name = payload["init_image_name"]# change this to "image_name"
+    
+    numOfAttempts = 3
+    init_img_str = ""
+    for i in range(numOfAttempts):
+        try:
+            image_path = f"{init_img_dir}/{init_img_name}"
+            init_img = Image.open(image_path)
+            init_img_str = img_2_b64(init_img)
+
+            
+            # # If file exists, delete it.
+            # if os.path.isfile(image_path):
+            #     os.remove(image_path)
+        except:
+            print(f"exception:fail to read an image file {image_path}, will try again {i} of {numOfAttempts}")
+            #sleep for one second every time you try to read an image and fail
+            time.sleep(1)
+            continue;
+    
+    
+    
+    return {"payload": payload,"init_image_str":init_img_str}
+
+@router.get('/config')
+async def sdapi(request: Request, response: Response):
+    try:
+        
+        resp = requests.get(url=f'{sd_url}/config', params=request.query_params)
+        response.status_code = resp.status_code
+        response.body = resp.content
+    except:
+        print(f'exception: fail to send request to {sd_url}/config')
+        print(f'{request}')
+    return response
+
+@router.get('/sdapi/v1/{path:path}')
+async def sdapi(path: str, request: Request, response: Response):
+    try:
+        
+        resp = requests.get(url=f'{sd_url}/sdapi/v1/{path}', params=request.query_params)
+        response.status_code = resp.status_code
+        response.body = resp.content
+    except:
+        print(f'exception: fail to send request to {sd_url}/sdapi/v1/{path}')
+        print(f'{request}')
+    return response
+
+@router.post('/sdapi/v1/{path:path}')
+async def sdapi(path: str, request: Request, response: Response):
+    try:
+        json = await request.json()
+    except: 
+        json = {}
+
+    try:
+        # if(path =="interrupt"):
+        #     resp = requests.post(url=f'{sd_url}/sdapi/v1/{path}', params=request.query_params)
+
+        # else:
+        #     resp = requests.post(url=f'{sd_url}/sdapi/v1/{path}', params=request.query_params, json=await request.json())
+        resp = requests.post(url=f'{sd_url}/sdapi/v1/{path}', params=request.query_params, json=json)
+
+        response.status_code = resp.status_code
+        response.body = resp.content
+    except:
+        print(f'exception: fail to send request to {sd_url}/sdapi/v1/{path}')
+        print(f'{request}')
+    return response
+
+
+
+# async def base64ToPng(base64_image,image_path):
+#     base64_img_bytes = base64_image.encode('utf-8')
+#     with open(image_path, 'wb') as file_to_save:
+#         decoded_image_data = base64.decodebytes(base64_img_bytes)
+#         file_to_save.write(decoded_image_data)
+
+
+@router.post('/save/png/')
+async def savePng(request:Request):
+    print("savePng()")
+    try:
+        json = await request.json()
+        
+    except: 
+        json = {}
+    
+    print("json:",json)
+    try:
+        folder = './init_images'
+        image_path = f"{folder}/{json['image_name']}"
+        await img2imgapi.base64ToPng(json['base64'],image_path)
+        
+        
+        
+        
+        return {"status":f"{json['image_name']} has been saved"}
+    except:
+        print(f'{request}')
+    return {"error": "error message: could not save the image file"}
+
+
+@router.post('/search/image/')
+async def searchImage(request:Request):
+    try:
+        json = await request.json()
+    except: 
+        json = {}
+    
+
+    try:
+        keywords = json.get('keywords','cute dogs') 
+        images = await search.imageSearch(keywords)
+        print(images)
+        
+        
+        return {"images":images}
+    except:
+        print("keywords",keywords)
+        # print(f'{request}')
+    return {"error": "error message: can't preform an image search"}
+
+@router.post('/mask/expansion/')
+async def maskExpansionHandler(request:Request):
+    try:
+        json = await request.json()
+    except: 
+        json = {}
+    
+
+    try:
+        # keywords = json.get('keywords','cute dogs') 
+        base64_mask_image = json['mask']
+        mask_expansion = json['mask_expansion']
+        #convert base64 to img
+        
+        await img2imgapi.base64ToPng(base64_mask_image,"original_mask.png")#save a copy of the mask for debugging
+
+        mask_image = img2imgapi.b64_2_img(base64_mask_image)
+        
+        expanded_mask_img = img2imgapi.maskExpansion(mask_image,mask_expansion)
+        base64_expanded_mask_image = img2imgapi.img_2_b64(expanded_mask_img)
+        await img2imgapi.base64ToPng(base64_expanded_mask_image,"expanded_mask.png")#save a copy of the mask of the expanded_mask for debugging
+
+        print("successful mask expansion operation")
+        return {"mask":base64_expanded_mask_image}
+    
+    except:
+        print("request",request)
+        raise Exception(f"couldn't preform mask expansion")
+    # return response
+    return {"error": "error message: can't preform an mask expansion"}
+
+
+@router.post('/history/load')
+async def loadHistory(request: Request):
+    # {'image_paths','metadata_setting'}
+    history = {}
+    try:
+        json = await request.json()
+    except: 
+        json = {}
+
+    try:
+
+        uniqueDocumentId = json['uniqueDocumentId']
+        
+        import glob
+
+        image_paths = glob.glob(f'./output/{uniqueDocumentId}/*.png')
+        settings_paths = glob.glob(f'./output/{uniqueDocumentId}/*.json')#note: why is we are not using settings_paths?
+        print("loadHistory: image_paths:", image_paths)
+        
+
+        history['image_paths'] = image_paths
+        history['metadata_jsons'] = []
+        history['base64_images'] = []
+        for image_path in image_paths:
+            print("image_path: ", image_path)
+            metadata_dict = metadata_to_json.createMetadataJsonFileIfNotExist(image_path)
+            history['metadata_jsons'].routerend(metadata_dict)
+            
+            
+            img = Image.open(image_path)
+            base64_image = img_2_b64(img)
+            history['base64_images'].routerend(base64_image)
+
+    except:
+        
+        print(f'{request}')
+    
+    #reverse the order so that newer generated images path will be shown first
+    
+
+    history['image_paths'].reverse()
+    history['metadata_jsons'].reverse()
+    history['base64_images'].reverse()    
+    return {"image_paths":history['image_paths'], "metadata_jsons":history['metadata_jsons'],"base64_images": history['base64_images']}
+
+
+@router.post('/prompt_shortcut/load')
+async def loadPromptShortcut(request: Request):
+    prompt_shortcut_json = {}
+    try:
+        json = await request.json()
+    except: 
+        json = {}
+
+    try:
+
+        prompt_shortcut_json = prompt_shortcut.load()
+        # response.body = {"prompt_shortcut":prompt_shortcut}
+        # response.status_code = 200
+    except:
+        # print(f'exception: fail to send request to {sd_url}/sdapi/v1/{path}')
+        print(f'{request}')
+        
+    # return response
+    return {"prompt_shortcut":prompt_shortcut_json}
+@router.post('/prompt_shortcut/save')
+async def loadPromptShortcut(request: Request):
+    prompt_shortcut_json = {}
+    try:
+        json = await request.json()
+    except: 
+        json = {}
+
+    try:
+        print("json: ",json)
+        print("json['prompt_shortcut']: ",json['prompt_shortcut'])
+        # save the prompt shortcut to the prompt_shortcut.json
+        prompt_shortcut_json = json['prompt_shortcut']
+        # response.body = {"prompt_shortcut":prompt_shortcut}
+        # response.body = {"prompt_shortcut":prompt_shortcut}
+        prompt_shortcut.writeToJson("prompt_shortcut.json",prompt_shortcut_json)
+    except:
+        # print(f'exception: fail to send request to {sd_url}/sdapi/v1/{path}')
+        print(f'error occurred durning reading the request {request}')
+    # return response
+    return {"prompt_shortcut":prompt_shortcut_json}
+
+@router.post("/swapModel")
+async def swapModel(request:Request):
+    print("swapModel: \n")
+    payload = await request.json()
+    print("payload:",payload)
+    model_title = payload.title
+    option_payload = {
+        # "sd_model_checkpoint": "Anything-V3.0-pruned.ckpt [2700c435]"
+        "sd_model_checkpoint": model_title
+
+    }
+    response = requests.post(url=f'{sd_url}/sdapi/v1/options', json=option_payload)
+
+
+import webbrowser
+@router.post("/open/url/")
+async def openUrl(request:Request):
+    try:
+        json = await request.json()
+    except: 
+        json = {}
+
+    url = "" 
+    print("json: ",json)
+    try:
+        url = json['url']
+        webbrowser.open(url)  # Go to example.com
+    except:
+        # print(f'exception: fail to send request to {sd_url}/sdapi/v1/{path}')
+        print(f'an error has occurred durning processing the request {request}')
+    # return response
+    return {"url":url}
+
+
+@router.get('/lora/list')
+async def list_available_loras():
+    lora_dict = {}
+    try:
+        from modules import shared
+        import glob
+
+        os.makedirs(shared.cmd_opts.lora_dir, exist_ok=True)
+
+        candidates = \
+            glob.glob(os.path.join(shared.cmd_opts.lora_dir, '**/*.pt'), recursive=True) + \
+            glob.glob(os.path.join(shared.cmd_opts.lora_dir, '**/*.safetensors'), recursive=True) + \
+            glob.glob(os.path.join(shared.cmd_opts.lora_dir, '**/*.ckpt'), recursive=True)
+
+        for filename in sorted(candidates, key=str.lower):
+            if os.path.isdir(filename):
+                continue
+
+            name = os.path.splitext(os.path.basename(filename))[0]
+            print("lora name: ",name)
+            # available_loras[name] = LoraOnDisk(name, filename)
+            lora_dict[name] = name
+
+    except Exception as e:
+        print("list_available_loras() error ",repr(e),e)
+    return lora_dict
+
+app = FastAPI()
+app.include_router(router)

Auto-Photoshop-StableDiffusion-Plugin/start_server.bat

@@ -0,0 +1,51 @@
+@REM @echo off
+git pull
+
+set SD_URL=http://127.0.0.1:7860
+
+echo does server_env\ exist
+if exist server_env\ (
+  echo Yes 
+  goto :activate_server_env
+) else (
+  echo No
+  goto :create_server_env
+)
+
+:create_server_env
+python -m venv server_env
+
+
+
+
+@REM pause
+
+
+:activate_server_env
+
+::run a server
+echo my_path: %~dp0
+@REM set current_dir=
+set VENV_DIR=%~dp0server_env
+@REM cd ./server_env/Scripts/
+set PYTHON="%VENV_DIR%\Scripts\Python.exe"
+%PYTHON% -m pip install -r requirements.txt
+
+cd ./server/python_server
+echo python path: %PYTHON%
+dir
+echo %PYTHON% uvicorn serverMain:app --reload
+%PYTHON% -m uvicorn serverMain:app --reload
+pause
+@REM exit /b
+@REM %PYTHON% uvicorn serverMain:app --reload
+pause
+
+@REM %PYTHON% img2imgapi.py
+@REM activate
+@REM echo server_env %PYTHON%
+@REM cd ./server/python_server
+@REM %PYTHON% img2imgapi.py
+@REM uvicorn serverMain:app --reload
+@REM dir .
+@REM call webui.bat

Auto-Photoshop-StableDiffusion-Plugin/start_server.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+git pull
+# Set the desired remote host where the "<>" is
+export SD_URL=http://127.0.0.1:7860
+
+# Check python was installed
+if ! hash python; then
+    echo "Python is not installed"
+    exit 1
+fi
+
+# Check the default python version
+orig_ver=$(python -V 2>&1)
+major_version=$(echo "$orig_ver" | sed 's/[^0-9]*\([0-9]*\)\..*/\1/')
+minor_subversion=$(echo "$orig_ver" | sed -E 's/^[^.]*\.([^.]*).*$/\1/')
+if [[ "$major_version" -ge "3" ]] && [[ "$minor_subversion" -ge "7" ]] # Because of uvicorn==0.20.0 in requirements
+then
+    echo "You have valid version of $orig_ver"
+else
+    echo "Your version $orig_ver not valid, should be >=3.7"
+    exit 1
+fi
+
+
+# Check if the desired environment exists
+if [ ! -d "server_env" ]; then
+  # Create the environment if it doesn't exist
+  python -m venv server_env
+  source ./server_env/bin/activate
+  python -m pip install -r requirements.txt
+else
+  source ./server_env/bin/activate
+fi
+
+cd ./server/python_server
+python -m uvicorn serverMain:app --reload

Auto-Photoshop-StableDiffusion-Plugin/start_server_MacOS.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+git pull
+# Set the desired remote host where the "<>" is
+export SD_URL=http://127.0.0.1:7860
+
+# Check if the desired environment exists
+if [ ! -d "server_env" ]; then
+  # Create the environment if it doesn't exist
+  python3 -m venv server_env
+  source ./server_env/bin/activate
+  python3 -m pip install -r requirements.txt
+else
+  source ./server_env/bin/activate
+fi
+
+cd ./server/python_server
+python3 -m uvicorn serverMain:app --reload