Moved module logic to separate module.

2024-09-18 14:25:23 -04:00
parent 7b5c8840a1
commit 15bca1c899
16 changed files with 1865 additions and 898 deletions
--- a/plugins/DupFileManager/DupFileManager.py
+++ b/plugins/DupFileManager/DupFileManager.py
@@ -3,7 +3,9 @@
 # Get the latest developers version from following link: https://github.com/David-Maisonave/Axter-Stash/tree/main/plugins/DupFileManager
 # Note: To call this script outside of Stash, pass argument --url 
 #       Example:    python DupFileManager.py --url http://localhost:9999 -a
-import os, sys, time, pathlib, argparse, platform, shutil, logging
+import ModulesValidate
+ModulesValidate.modulesInstalled(["send2trash", "requests"])
+import os, sys, time, pathlib, argparse, platform, shutil, traceback, logging, requests
 from StashPluginHelper import StashPluginHelper
 from stashapi.stash_types import PhashDistance
 from DupFileManager_config import config # Import config from DupFileManager_config.py
@@ -18,11 +20,13 @@ parser.add_argument('--remove_dup', '-r', dest='remove', action='store_true', he
 parse_args = parser.parse_args()

 settings = {
+    "clearAllDupfileManagerTags": False,
    "doNotGeneratePhash": False,
    "mergeDupFilename": False,
    "permanentlyDelete": False,
    "whitelistDelDupInSameFolder": False,
    "whitelistDoTagLowResDup": False,
+    "xGrayListTagging": False,
    "zCleanAfterDel": False,
    "zSwapHighRes": False,
    "zSwapLongLength": False,
@@ -34,7 +38,8 @@ settings = {
    "zyBlacklist": "",
    "zyMatchDupDistance": 0,
    "zyMaxDupToProcess": 0,
-    "zzdebugTracing": False,
+    "zzDebug": False,
+    "zzTracing": False,
 }
 stash = StashPluginHelper(
        stash_url=parse_args.stash_url,
@@ -42,29 +47,33 @@ stash = StashPluginHelper(
        settings=settings,
        config=config,
        maxbytes=10*1024*1024,
+        DebugTraceFieldName="zzTracing",
+        DebugFieldName="zzDebug",
        )
 stash.convertToAscii = True
+stash.Log("******************* Starting   *******************")
 if len(sys.argv) > 1:
    stash.Log(f"argv = {sys.argv}")
 else:
    stash.Trace(f"No command line arguments. JSON_INPUT['args'] = {stash.JSON_INPUT['args']}")
 stash.status(logLevel=logging.DEBUG)

-stash.modulesInstalled(["send2trash", "requests"])

 # stash.Trace(f"\nStarting (__file__={__file__}) (stash.CALLED_AS_STASH_PLUGIN={stash.CALLED_AS_STASH_PLUGIN}) (stash.DEBUG_TRACING={stash.DEBUG_TRACING}) (stash.PLUGIN_TASK_NAME={stash.PLUGIN_TASK_NAME})************************************************")
 # stash.encodeToUtf8 = True


-LOG_STASH_N_PLUGIN = stash.LOG_TO_STASH if stash.CALLED_AS_STASH_PLUGIN else stash.LOG_TO_CONSOLE + stash.LOG_TO_FILE
+LOG_STASH_N_PLUGIN = stash.LogTo.STASH if stash.CALLED_AS_STASH_PLUGIN else stash.LogTo.CONSOLE + stash.LogTo.FILE
 listSeparator               = stash.Setting('listSeparator', ',', notEmpty=True)
 addPrimaryDupPathToDetails  = stash.Setting('addPrimaryDupPathToDetails') 
+clearAllDupfileManagerTags  = stash.Setting('clearAllDupfileManagerTags')
 doNotGeneratePhash          = stash.Setting('doNotGeneratePhash')
 mergeDupFilename            = stash.Setting('mergeDupFilename')
 moveToTrashCan              = False if stash.Setting('permanentlyDelete') else True
 alternateTrashCanPath       = stash.Setting('dup_path')
 whitelistDelDupInSameFolder = stash.Setting('whitelistDelDupInSameFolder')
 whitelistDoTagLowResDup     = stash.Setting('whitelistDoTagLowResDup')
+grayListTagging             = stash.Setting('xGrayListTagging')
 maxDupToProcess             = int(stash.Setting('zyMaxDupToProcess'))
 significantTimeDiff         = stash.Setting('significantTimeDiff')
 toRecycleBeforeSwap         = stash.Setting('toRecycleBeforeSwap')
@@ -93,6 +102,9 @@ else:
    codecRanking            = stash.Setting('codecRankingSet1')
 skipIfTagged                = stash.Setting('skipIfTagged')
 killScanningPostProcess     = stash.Setting('killScanningPostProcess')
+tagLongDurationLowRes       = stash.Setting('tagLongDurationLowRes')
+bitRateIsImporantComp       = stash.Setting('bitRateIsImporantComp')
+codecIsImporantComp         = stash.Setting('codecIsImporantComp')

 matchDupDistance            = int(stash.Setting('zyMatchDupDistance'))
 matchPhaseDistance          = PhashDistance.EXACT
@@ -103,6 +115,9 @@ if matchDupDistance == 1:
 elif matchDupDistance == 2:
    matchPhaseDistance      = PhashDistance.MEDIUM
    matchPhaseDistanceText  = "Medium Match"
+elif matchDupDistance == 3:
+    matchPhaseDistance      = PhashDistance.LOW
+    matchPhaseDistanceText  = "Low Match"

 # significantTimeDiff can not be higher than 1 and shouldn't be lower than .5
 if significantTimeDiff > 1:
@@ -123,6 +138,14 @@ excludeDupFileDeleteTag = stash.Setting('excludeDupFileDeleteTag')
 if excludeDupFileDeleteTag == "":
    excludeDupFileDeleteTag = '_ExcludeDuplicateMarkForDeletion'

+graylistMarkForDeletion = stash.Setting('graylistMarkForDeletion')
+if graylistMarkForDeletion == "":
+    graylistMarkForDeletion = '_GraylistMarkForDeletion'
+
+longerDurationLowerResolution = stash.Setting('longerDurationLowerResolution')
+if longerDurationLowerResolution == "":
+    longerDurationLowerResolution = '_LongerDurationLowerResolution'
+
 excludeMergeTags = [duplicateMarkForDeletion, duplicateWhitelistTag, excludeDupFileDeleteTag]
 stash.initMergeMetadata(excludeMergeTags)

@@ -234,12 +257,27 @@ def setTagId(tagName, sceneDetails, DupFileToKeep, TagReason="", ignoreAutoTag=F
    if details != "":
        dataDict.update({'details' : details})
    if dataDict != ORG_DATA_DICT:
-        stash.update_scene(dataDict)
-        stash.Trace(f"[setTagId] Updated {sceneDetails['files'][0]['path']} with metadata {dataDict}", toAscii=True)
+        stash.updateScene(dataDict)
+        stash.Trace(f"[setTagId] Updated {sceneDetails['files'][0]['path']} with metadata {dataDict} and tag {tagName}", toAscii=True)
    else:
-        stash.Trace(f"[setTagId] Nothing to update {sceneDetails['files'][0]['path']}.", toAscii=True)
+        stash.Trace(f"[setTagId] Nothing to update {sceneDetails['files'][0]['path']} already has tag {tagName}.", toAscii=True)
    return doAddTag

+def setTagId_withRetry(tagName, sceneDetails, DupFileToKeep, TagReason="", ignoreAutoTag=False, retryCount = 12, sleepSecondsBetweenRetry = 5):
+    errMsg = None
+    for i in range(0, retryCount):
+        try:
+            if errMsg != None:
+                stash.Warn(errMsg)
+            return setTagId(tagName, sceneDetails, DupFileToKeep, TagReason, ignoreAutoTag)
+        except (requests.exceptions.ConnectionError, ConnectionResetError):
+            tb = traceback.format_exc()
+            errMsg = f"[setTagId] Exception calling setTagId. Will retry; count({i}); Error: {e}\nTraceBack={tb}"
+        except Exception as e:
+            tb = traceback.format_exc()
+            errMsg = f"[setTagId] Unknown exception calling setTagId. Will retry; count({i}); Error: {e}\nTraceBack={tb}"
+        time.sleep(sleepSecondsBetweenRetry)
+
 def hasSameDir(path1, path2):
    if pathlib.Path(path1).resolve().parent == pathlib.Path(path2).resolve().parent:
        return True
@@ -263,13 +301,19 @@ def sendToTrash(path):
            stash.Error(f"Failed to delete file {path}. Error: {e}", toAscii=True)
    return False

-def significantLessTime(durrationToKeep, durrationOther):
-    timeDiff = durrationToKeep / durrationOther
+def significantLessTime(durration1, durration2): # Where durration1 is ecpected to be smaller than durration2 IE(45/60=.75)
+    if 'files' in durration1:
+        durration1 = int(durration1['files'][0]['duration'])
+        durration2 = int(durration2['files'][0]['duration'])
+    timeDiff = getTimeDif(durration1, durration2)
    if timeDiff < significantTimeDiff:
        return True
    return False

-def isBetterVideo(scene1, scene2, swapCandidateCk = False):
+def getTimeDif(durration1, durration2): # Where durration1 is ecpected to be smaller than durration2 IE(45/60=.75)
+    return durration1 / durration2
+
+def isBetterVideo(scene1, scene2, swapCandidateCk = False): # is scene2 better than scene1
    # Prioritize higher reslution over codec, bit rate, and frame rate
    if int(scene1['files'][0]['width']) > int(scene2['files'][0]['width']) or int(scene1['files'][0]['height']) > int(scene2['files'][0]['height']):
        return False
@@ -289,12 +333,38 @@ def isBetterVideo(scene1, scene2, swapCandidateCk = False):
            return True
    return False

+def significantMoreTimeCompareToBetterVideo(scene1, scene2): # is scene2 better than scene1
+    if int(scene1['files'][0]['duration']) >= int(scene2['files'][0]['duration']):
+        return False
+    if int(scene1['files'][0]['width']) > int(scene2['files'][0]['width']) or int(scene1['files'][0]['height']) > int(scene2['files'][0]['height']):
+        if significantLessTime(scene1, scene2):
+            if tagLongDurationLowRes:
+                didAddTag = setTagId_withRetry(longerDurationLowerResolution, scene2, scene1, ignoreAutoTag=True)
+                stash.Log(f"Tagged sene2 with tag {longerDurationLowerResolution}, because scene1 is better video, but it has significant less time ({getTimeDif(int(scene1['files'][0]['duration']), int(scene2['files'][0]['duration']))}%) compare to scene2; scene1={scene1['files'][0]['path']} (ID={scene1['id']})(duration={scene1['files'][0]['duration']}); scene2={scene2['files'][0]['path']} (ID={scene2['id']}) (duration={scene1['files'][0]['duration']}); didAddTag={didAddTag}")
+            else:
+                stash.Warn(f"Scene1 is better video, but it has significant less time ({getTimeDif(int(scene1['files'][0]['duration']), int(scene2['files'][0]['duration']))}%) compare to scene2; Scene1={scene1['files'][0]['path']} (ID={scene1['id']})(duration={scene1['files'][0]['duration']}); Scene2={scene2['files'][0]['path']} (ID={scene2['id']}) (duration={scene1['files'][0]['duration']})")            
+        return False
+    return True
+
+def allThingsEqual(scene1, scene2): # If all important things are equal, return true
+    if int(scene1['files'][0]['duration']) != int(scene2['files'][0]['duration']):
+        return False
+    if scene1['files'][0]['width'] != scene2['files'][0]['width']:
+        return False
+    if scene1['files'][0]['height'] != scene2['files'][0]['height']:
+        return False
+    if bitRateIsImporantComp and scene1['files'][0]['bit_rate'] != scene2['files'][0]['bit_rate']:
+        return False
+    if codecIsImporantComp and scene1['files'][0]['video_codec'] != scene2['files'][0]['video_codec']:
+        return False
+    return True
+
 def isSwapCandidate(DupFileToKeep, DupFile):
    # Don't move if both are in whitelist
    if stash.startsWithInList(whitelist, DupFileToKeep['files'][0]['path']) and stash.startsWithInList(whitelist, DupFile['files'][0]['path']):
        return False
    if swapHighRes and (int(DupFileToKeep['files'][0]['width']) > int(DupFile['files'][0]['width']) or int(DupFileToKeep['files'][0]['height']) > int(DupFile['files'][0]['height'])):
-        if not significantLessTime(int(DupFileToKeep['files'][0]['duration']), int(DupFile['files'][0]['duration'])):
+        if not significantLessTime(DupFileToKeep, DupFile):
            return True
        else:
            stash.Warn(f"File '{DupFileToKeep['files'][0]['path']}' has a higher resolution than '{DupFile['files'][0]['path']}', but the duration is significantly shorter.", toAscii=True)
@@ -302,10 +372,10 @@ def isSwapCandidate(DupFileToKeep, DupFile):
        if int(DupFileToKeep['files'][0]['width']) >= int(DupFile['files'][0]['width']) or int(DupFileToKeep['files'][0]['height']) >= int(DupFile['files'][0]['height']):
            return True
    if isBetterVideo(DupFile, DupFileToKeep, swapCandidateCk=True):
-        if not significantLessTime(int(DupFileToKeep['files'][0]['duration']), int(DupFile['files'][0]['duration'])):
+        if not significantLessTime(DupFileToKeep, DupFile):
            return True
        else:
-            stash.Warn(f"File '{DupFileToKeep['files'][0]['path']}' has better codec/bit-rate than '{DupFile['files'][0]['path']}', but the duration is significantly shorter.", toAscii=True)
+            stash.Warn(f"File '{DupFileToKeep['files'][0]['path']}' has better codec/bit-rate than '{DupFile['files'][0]['path']}', but the duration is significantly shorter; DupFileToKeep-ID={DupFileToKeep['id']};DupFile-ID={DupFile['id']};BitRate {DupFileToKeep['files'][0]['bit_rate']} vs {DupFile['files'][0]['bit_rate']};Codec {DupFileToKeep['files'][0]['video_codec']} vs {DupFile['files'][0]['video_codec']};FrameRate {DupFileToKeep['files'][0]['frame_rate']} vs {DupFile['files'][0]['frame_rate']};", toAscii=True)
    return False

 dupWhitelistTagId = None
@@ -344,6 +414,14 @@ def isWorseKeepCandidate(DupFileToKeep, Scene):
        return True      
    return False

+def killScanningJobs():
+    try:
+        if killScanningPostProcess:
+            stash.stopJobs(0, "Scanning...")
+    except Exception as e:
+        tb = traceback.format_exc()
+        stash.Error(f"Exception while trying to kill scan jobs; Error: {e}\nTraceBack={tb}")
+
 def mangeDupFiles(merge=False, deleteDup=False, tagDuplicates=False):
    duplicateMarkForDeletion_descp = 'Tag added to duplicate scenes so-as to tag them for deletion.'
    stash.Trace(f"duplicateMarkForDeletion = {duplicateMarkForDeletion}")    
@@ -373,6 +451,7 @@ def mangeDupFiles(merge=False, deleteDup=False, tagDuplicates=False):
    DupFileSets = stash.find_duplicate_scenes(matchPhaseDistance, fragment='id tags {id name} files {path width height duration size video_codec bit_rate frame_rate} details ' + mergeFieldData)
    stash.stopSpinningProcessBar()
    qtyResults = len(DupFileSets)
+    stash.setProgressBarIter(qtyResults)
    stash.Trace("#########################################################################")
    stash.Log(f"Found {qtyResults} duplicate sets...")
    for DupFileSet in DupFileSets:
@@ -380,7 +459,7 @@ def mangeDupFiles(merge=False, deleteDup=False, tagDuplicates=False):
        QtyDupSet+=1
        stash.progressBar(QtyDupSet, qtyResults)
        SepLine = "---------------------------"
-        DupFileToKeep = ""
+        DupFileToKeep = None
        DupToCopyFrom = ""
        DupFileDetailList = []
        for DupFile in DupFileSet:
@@ -390,63 +469,68 @@ def mangeDupFiles(merge=False, deleteDup=False, tagDuplicates=False):
            if skipIfTagged and duplicateMarkForDeletion in Scene['tags']:
                stash.Trace(f"Skipping scene '{Scene['files'][0]['path']}' because already tagged with {duplicateMarkForDeletion}")
                continue
-            stash.Trace(f"Scene = {Scene}", toAscii=True)
+            stash.TraceOnce(f"Scene = {Scene}", toAscii=True)
            DupFileDetailList = DupFileDetailList + [Scene]
-            if DupFileToKeep != "":
-                if int(DupFileToKeep['files'][0]['duration']) == int(Scene['files'][0]['duration']): # Do not count fractions of a second as a difference
-                    QtyExactDup+=1
+            if os.path.isfile(Scene['files'][0]['path']):
+                if DupFileToKeep != None:
+                    if int(DupFileToKeep['files'][0]['duration']) == int(Scene['files'][0]['duration']): # Do not count fractions of a second as a difference
+                        QtyExactDup+=1
+                    else:
+                        QtyAlmostDup+=1
+                        SepLine = "***************************"
+                        if significantLessTime(DupFileToKeep, Scene):
+                            QtyRealTimeDiff += 1
+                    
+                    if int(DupFileToKeep['files'][0]['width']) < int(Scene['files'][0]['width']) or int(DupFileToKeep['files'][0]['height']) < int(Scene['files'][0]['height']):
+                        stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=resolution: {DupFileToKeep['files'][0]['width']}x{DupFileToKeep['files'][0]['height']} < {Scene['files'][0]['width']}x{Scene['files'][0]['height']}")
+                        DupFileToKeep = Scene
+                    elif significantMoreTimeCompareToBetterVideo(DupFileToKeep, Scene):
+                        stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=duration: {DupFileToKeep['files'][0]['duration']} < {Scene['files'][0]['duration']}")
+                        DupFileToKeep = Scene
+                    elif isBetterVideo(DupFileToKeep, Scene):
+                        stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=codec,bit_rate, or frame_rate: {DupFileToKeep['files'][0]['video_codec']}, {DupFileToKeep['files'][0]['bit_rate']}, {DupFileToKeep['files'][0]['frame_rate']} : {Scene['files'][0]['video_codec']}, {Scene['files'][0]['bit_rate']}, {Scene['files'][0]['frame_rate']}")
+                        DupFileToKeep = Scene
+                    elif stash.startsWithInList(whitelist, Scene['files'][0]['path']) and not stash.startsWithInList(whitelist, DupFileToKeep['files'][0]['path']):
+                        stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=not whitelist vs whitelist")
+                        DupFileToKeep = Scene
+                    elif isTaggedExcluded(Scene) and not isTaggedExcluded(DupFileToKeep):
+                        stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=not ExcludeTag vs ExcludeTag")
+                        DupFileToKeep = Scene
+                    elif stash.startsWithInList(blacklist, DupFileToKeep['files'][0]['path']) and not stash.startsWithInList(blacklist, Scene['files'][0]['path']):
+                        stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=blacklist vs not blacklist")
+                        DupFileToKeep = Scene
+                    elif stash.startsWithInList(blacklist, DupFileToKeep['files'][0]['path']) and stash.startsWithInList(blacklist, Scene['files'][0]['path']) and stash.indexStartsWithInList(blacklist, DupFileToKeep['files'][0]['path']) > stash.indexStartsWithInList(blacklist, Scene['files'][0]['path']):
+                        stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=blacklist-index {stash.indexStartsWithInList(blacklist, DupFileToKeep['files'][0]['path'])} > {stash.indexStartsWithInList(blacklist, Scene['files'][0]['path'])}")
+                        DupFileToKeep = Scene
+                    elif stash.startsWithInList(graylist, Scene['files'][0]['path']) and not stash.startsWithInList(graylist, DupFileToKeep['files'][0]['path']):
+                        stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=not graylist vs graylist")
+                        DupFileToKeep = Scene
+                    elif stash.startsWithInList(graylist, Scene['files'][0]['path']) and stash.startsWithInList(graylist, DupFileToKeep['files'][0]['path']) and stash.indexStartsWithInList(graylist, DupFileToKeep['files'][0]['path']) > stash.indexStartsWithInList(graylist, Scene['files'][0]['path']):
+                        stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=graylist-index {stash.indexStartsWithInList(graylist, DupFileToKeep['files'][0]['path'])} > {stash.indexStartsWithInList(graylist, Scene['files'][0]['path'])}")
+                        DupFileToKeep = Scene
+                    elif allThingsEqual(DupFileToKeep, Scene):
+                        # Only do below checks if all imporant things are equal.
+                        if favorLongerFileName and len(DupFileToKeep['files'][0]['path']) < len(Scene['files'][0]['path']) and not isWorseKeepCandidate(DupFileToKeep, Scene):
+                            stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=path-len {len(DupFileToKeep['files'][0]['path'])} < {len(Scene['files'][0]['path'])}")
+                            DupFileToKeep = Scene
+                        elif favorLargerFileSize and int(DupFileToKeep['files'][0]['size']) < int(Scene['files'][0]['size']) and not isWorseKeepCandidate(DupFileToKeep, Scene):
+                            stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=size {DupFileToKeep['files'][0]['size']} < {Scene['files'][0]['size']}")
+                            DupFileToKeep = Scene
+                        elif not favorLongerFileName and len(DupFileToKeep['files'][0]['path']) > len(Scene['files'][0]['path']) and not isWorseKeepCandidate(DupFileToKeep, Scene):
+                            stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=path-len {len(DupFileToKeep['files'][0]['path'])} > {len(Scene['files'][0]['path'])}")
+                            DupFileToKeep = Scene
+                        elif not favorLargerFileSize and int(DupFileToKeep['files'][0]['size']) > int(Scene['files'][0]['size']) and not isWorseKeepCandidate(DupFileToKeep, Scene):
+                            stash.Debug(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=size {DupFileToKeep['files'][0]['size']} > {Scene['files'][0]['size']}")
+                            DupFileToKeep = Scene
                else:
-                    QtyAlmostDup+=1
-                    SepLine = "***************************"
-                    if significantLessTime(int(DupFileToKeep['files'][0]['duration']), int(Scene['files'][0]['duration'])):
-                        QtyRealTimeDiff += 1
-                
-                if int(DupFileToKeep['files'][0]['width']) < int(Scene['files'][0]['width']) or int(DupFileToKeep['files'][0]['height']) < int(Scene['files'][0]['height']):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=resolution: {DupFileToKeep['files'][0]['width']}x{DupFileToKeep['files'][0]['height']} < {Scene['files'][0]['width']}x{Scene['files'][0]['height']}")
-                    DupFileToKeep = Scene
-                elif int(DupFileToKeep['files'][0]['duration']) < int(Scene['files'][0]['duration']):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=duration: {DupFileToKeep['files'][0]['duration']} < {Scene['files'][0]['duration']}")
-                    DupFileToKeep = Scene
-                elif isBetterVideo(DupFileToKeep, Scene):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=codec,bit_rate, or frame_rate: {DupFileToKeep['files'][0]['video_codec']}, {DupFileToKeep['files'][0]['bit_rate']}, {DupFileToKeep['files'][0]['frame_rate']} : {Scene['files'][0]['video_codec']}, {Scene['files'][0]['bit_rate']}, {Scene['files'][0]['frame_rate']}")
-                    DupFileToKeep = Scene
-                elif stash.startsWithInList(whitelist, Scene['files'][0]['path']) and not stash.startsWithInList(whitelist, DupFileToKeep['files'][0]['path']):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=not whitelist vs whitelist")
-                    DupFileToKeep = Scene
-                elif isTaggedExcluded(Scene) and not isTaggedExcluded(DupFileToKeep):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=not ExcludeTag vs ExcludeTag")
-                    DupFileToKeep = Scene
-                elif stash.startsWithInList(blacklist, DupFileToKeep['files'][0]['path']) and not stash.startsWithInList(blacklist, Scene['files'][0]['path']):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=blacklist vs not blacklist")
-                    DupFileToKeep = Scene
-                elif stash.startsWithInList(blacklist, DupFileToKeep['files'][0]['path']) and stash.startsWithInList(blacklist, Scene['files'][0]['path']) and stash.indexStartsWithInList(blacklist, DupFileToKeep['files'][0]['path']) > stash.indexStartsWithInList(blacklist, Scene['files'][0]['path']):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=blacklist-index {stash.indexStartsWithInList(blacklist, DupFileToKeep['files'][0]['path'])} > {stash.indexStartsWithInList(blacklist, Scene['files'][0]['path'])}")
-                    DupFileToKeep = Scene
-                elif stash.startsWithInList(graylist, Scene['files'][0]['path']) and not stash.startsWithInList(graylist, DupFileToKeep['files'][0]['path']):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=not graylist vs graylist")
-                    DupFileToKeep = Scene
-                elif stash.startsWithInList(graylist, Scene['files'][0]['path']) and stash.startsWithInList(graylist, DupFileToKeep['files'][0]['path']) and stash.indexStartsWithInList(graylist, DupFileToKeep['files'][0]['path']) > stash.indexStartsWithInList(graylist, Scene['files'][0]['path']):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=graylist-index {stash.indexStartsWithInList(graylist, DupFileToKeep['files'][0]['path'])} > {stash.indexStartsWithInList(graylist, Scene['files'][0]['path'])}")
-                    DupFileToKeep = Scene
-                elif favorLongerFileName and len(DupFileToKeep['files'][0]['path']) < len(Scene['files'][0]['path']) and not isWorseKeepCandidate(DupFileToKeep, Scene):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=path-len {len(DupFileToKeep['files'][0]['path'])} < {len(Scene['files'][0]['path'])}")
-                    DupFileToKeep = Scene
-                elif favorLargerFileSize and int(DupFileToKeep['files'][0]['size']) < int(Scene['files'][0]['size']) and not isWorseKeepCandidate(DupFileToKeep, Scene):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=size {DupFileToKeep['files'][0]['size']} < {Scene['files'][0]['size']}")
-                    DupFileToKeep = Scene
-                elif not favorLongerFileName and len(DupFileToKeep['files'][0]['path']) > len(Scene['files'][0]['path']) and not isWorseKeepCandidate(DupFileToKeep, Scene):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=path-len {len(DupFileToKeep['files'][0]['path'])} > {len(Scene['files'][0]['path'])}")
-                    DupFileToKeep = Scene
-                elif not favorLargerFileSize and int(DupFileToKeep['files'][0]['size']) > int(Scene['files'][0]['size']) and not isWorseKeepCandidate(DupFileToKeep, Scene):
-                    stash.Trace(f"Replacing {DupFileToKeep['files'][0]['path']} with {Scene['files'][0]['path']} for candidate to keep. Reason=size {DupFileToKeep['files'][0]['size']} > {Scene['files'][0]['size']}")
                    DupFileToKeep = Scene
+                # stash.Trace(f"DupFileToKeep = {DupFileToKeep}")
+                stash.Debug(f"KeepID={DupFileToKeep['id']}, ID={DupFile['id']} duration=({Scene['files'][0]['duration']}), Size=({Scene['files'][0]['size']}), Res=({Scene['files'][0]['width']} x {Scene['files'][0]['height']}) Name={Scene['files'][0]['path']}, KeepPath={DupFileToKeep['files'][0]['path']}", toAscii=True)
            else:
-                DupFileToKeep = Scene
-            # stash.Trace(f"DupFileToKeep = {DupFileToKeep}")
-            stash.Trace(f"KeepID={DupFileToKeep['id']}, ID={DupFile['id']} duration=({Scene['files'][0]['duration']}), Size=({Scene['files'][0]['size']}), Res=({Scene['files'][0]['width']} x {Scene['files'][0]['height']}) Name={Scene['files'][0]['path']}, KeepPath={DupFileToKeep['files'][0]['path']}", toAscii=True)
+                stash.Error(f"Scene does NOT exist; path={Scene['files'][0]['path']}; ID={Scene['id']}")
        
        for DupFile in DupFileDetailList:
-            if DupFile['id'] != DupFileToKeep['id']:
+            if DupFileToKeep != None and DupFile['id'] != DupFileToKeep['id']:
                if merge:
                    result = stash.mergeMetadata(DupFile, DupFileToKeep)
                    if result != "Nothing To Merge":
@@ -459,24 +543,28 @@ def mangeDupFiles(merge=False, deleteDup=False, tagDuplicates=False):
                            stash.mergeMetadata(DupFileToKeep, DupFile)
                        if toRecycleBeforeSwap:
                            sendToTrash(DupFile['files'][0]['path'])
-                        shutil.move(DupFileToKeep['files'][0]['path'], DupFile['files'][0]['path'])
-                        QtySwap+=1
-                        stash.Log(f"Moved better file '{DupFileToKeep['files'][0]['path']}' to '{DupFile['files'][0]['path']}';QtyDup={QtyDup};QtySwap={QtySwap};QtySkipForDel={QtySkipForDel}", toAscii=True, printTo=LOG_STASH_N_PLUGIN)
+                        stash.Log(f"Moving better file '{DupFileToKeep['files'][0]['path']}' to '{DupFile['files'][0]['path']}'; SrcID={DupFileToKeep['id']};DescID={DupFile['id']};QtyDup={QtyDup};Set={QtyDupSet} of {qtyResults};QtySwap={QtySwap};QtySkipForDel={QtySkipForDel}", toAscii=True, printTo=LOG_STASH_N_PLUGIN)
+                        try:
+                            shutil.move(DupFileToKeep['files'][0]['path'], DupFile['files'][0]['path'])
+                            QtySwap+=1
+                        except Exception as e:
+                            tb = traceback.format_exc()
+                            stash.Error(f"Exception while moving file '{DupFileToKeep['files'][0]['path']}' to '{DupFile['files'][0]['path']}; SrcID={DupFileToKeep['id']};DescID={DupFile['id']}'; Error: {e}\nTraceBack={tb}")
                        DupFileToKeep = DupFile
                    else:
                        if dupWhitelistTagId and tagDuplicates:
-                            didAddTag = setTagId(duplicateWhitelistTag, DupFile, DupFileToKeep, ignoreAutoTag=True)
-                        stash.Log(f"NOT processing duplicate, because it's in whitelist. '{DupFile['files'][0]['path']}';didAddWhiteTag={didAddTag};QtyDup={QtyDup};QtySkipForDel={QtySkipForDel}", toAscii=True)
+                            didAddTag = setTagId_withRetry(duplicateWhitelistTag, DupFile, DupFileToKeep, ignoreAutoTag=True)
+                        stash.Log(f"NOT processing duplicate, because it's in whitelist. '{DupFile['files'][0]['path']}';AddTagW={didAddTag};QtyDup={QtyDup};Set={QtyDupSet} of {qtyResults};QtySkipForDel={QtySkipForDel}", toAscii=True)
                else:
                    if isTaggedExcluded(DupFile):
                        QtyExcludeForDel+=1
-                        stash.Log(f"Excluding file {DupFile['files'][0]['path']} because tagged for exclusion via tag {excludeDupFileDeleteTag};QtyDup={QtyDup}")
+                        stash.Log(f"Excluding file {DupFile['files'][0]['path']} because tagged for exclusion via tag {excludeDupFileDeleteTag};QtyDup={QtyDup};Set={QtyDupSet} of {qtyResults}")
                    else:
                        if deleteDup:
                            QtyDeleted += 1
                            DupFileName = DupFile['files'][0]['path']
                            DupFileNameOnly = pathlib.Path(DupFileName).stem
-                            stash.Warn(f"Deleting duplicate '{DupFileName}';QtyDup={QtyDup};QtyDeleted={QtyDeleted}", toAscii=True, printTo=LOG_STASH_N_PLUGIN)
+                            stash.Warn(f"Deleting duplicate '{DupFileName}';QtyDup={QtyDup};Set={QtyDupSet} of {qtyResults};QtyDeleted={QtyDeleted}", toAscii=True, printTo=LOG_STASH_N_PLUGIN)
                            if alternateTrashCanPath != "":
                                destPath = f"{alternateTrashCanPath }{os.sep}{DupFileNameOnly}"
                                if os.path.isfile(destPath):
@@ -484,51 +572,60 @@ def mangeDupFiles(merge=False, deleteDup=False, tagDuplicates=False):
                                shutil.move(DupFileName, destPath)
                            elif moveToTrashCan:
                                sendToTrash(DupFileName)
-                            stash.destroy_scene(DupFile['id'], delete_file=True)
+                            stash.destroyScene(DupFile['id'], delete_file=True)
                        elif tagDuplicates:
                            QtyTagForDel+=1
-                            didAddTag = setTagId(duplicateMarkForDeletion, DupFile, DupFileToKeep, ignoreAutoTag=True)
+                            didAddTag = setTagId_withRetry(duplicateMarkForDeletion, DupFile, DupFileToKeep, ignoreAutoTag=True)
+                            if grayListTagging and stash.startsWithInList(graylist, DupFile['files'][0]['path']):
+                                stash.addTag(DupFile, graylistMarkForDeletion, ignoreAutoTag=True)
                            if didAddTag:
                                QtyNewlyTag+=1
                            if QtyTagForDel == 1:
-                                stash.Log(f"Tagging duplicate {DupFile['files'][0]['path']} for deletion with tag {duplicateMarkForDeletion};didAddTag={didAddTag};QtyDup={QtyDup};QtyNewlyTag={QtyNewlyTag};QtyTagForDel={QtyTagForDel}", toAscii=True, printTo=LOG_STASH_N_PLUGIN)
+                                stash.Log(f"Tagging duplicate {DupFile['files'][0]['path']} for deletion with tag {duplicateMarkForDeletion}", toAscii=True, printTo=LOG_STASH_N_PLUGIN)
                            else:
-                                stash.Log(f"Tagging duplicate {DupFile['files'][0]['path']} for deletion;didAddTag={didAddTag};QtyDup={QtyDup};QtyNewlyTag={QtyNewlyTag};QtyTagForDel={QtyTagForDel}", toAscii=True, printTo=LOG_STASH_N_PLUGIN)
+                                didAddTag = 1 if didAddTag else 0
+                                stash.Log(f"Tagging duplicate {DupFile['files'][0]['path']} for deletion;AddTag={didAddTag};Qty={QtyDup};Set={QtyDupSet} of {qtyResults};NewlyTag={QtyNewlyTag};isTag={QtyTagForDel}", toAscii=True, printTo=LOG_STASH_N_PLUGIN)
        stash.Trace(SepLine)
        if maxDupToProcess > 0 and QtyDup > maxDupToProcess:
            break
    
+    stash.Debug("#####################################################")
    stash.Log(f"QtyDupSet={QtyDupSet}, QtyDup={QtyDup}, QtyDeleted={QtyDeleted}, QtySwap={QtySwap}, QtyTagForDel={QtyTagForDel}, QtySkipForDel={QtySkipForDel}, QtyExcludeForDel={QtyExcludeForDel}, QtyExactDup={QtyExactDup}, QtyAlmostDup={QtyAlmostDup}, QtyMerge={QtyMerge}, QtyRealTimeDiff={QtyRealTimeDiff}", printTo=LOG_STASH_N_PLUGIN)
-    if killScanningPostProcess:
-        stash.stopJobs(0, "Scanning...")
-    if doNotGeneratePhash == False:
-        stash.metadata_generate({"phashes": True})
+    killScanningJobs()
    if cleanAfterDel:
        stash.Log("Adding clean jobs to the Task Queue", printTo=LOG_STASH_N_PLUGIN)
-        stash.metadata_clean(paths=stash.STASH_PATHS)
+        stash.metadata_clean()
        stash.metadata_clean_generated()
        stash.optimise_database()
+    if doNotGeneratePhash == False:
+        stash.metadata_generate({"phashes": True})

-def manageTagggedDuplicates(clearTag=False):
+def manageTagggedDuplicates(deleteScenes=False, clearTag=False, setGrayListTag=False):
    tagId = stash.find_tags(q=duplicateMarkForDeletion)
    if len(tagId) > 0 and 'id' in tagId[0]:
        tagId = tagId[0]['id']
    else:
        stash.Warn(f"Could not find tag ID for tag '{duplicateMarkForDeletion}'.")
        return
+    
+    excludedTags = [duplicateMarkForDeletion]
+    if clearAllDupfileManagerTags:
+        excludedTags = [duplicateMarkForDeletion, duplicateWhitelistTag, excludeDupFileDeleteTag, graylistMarkForDeletion, longerDurationLowerResolution]
+    
    QtyDup = 0
    QtyDeleted = 0
    QtyClearedTags = 0
+    QtySetGraylistTag = 0
    QtyFailedQuery = 0
-    stash.Trace("#########################################################################")
+    stash.Debug("#########################################################################")
    stash.startSpinningProcessBar()
    scenes = stash.find_scenes(f={"tags": {"value":tagId, "modifier":"INCLUDES"}}, fragment='id tags {id name} files {path width height duration size video_codec bit_rate frame_rate} details')
    stash.stopSpinningProcessBar()
    qtyResults = len(scenes)
-    stash.Trace(f"Found {qtyResults} scenes with tag ({duplicateMarkForDeletion})")
+    stash.Log(f"Found {qtyResults} scenes with tag ({duplicateMarkForDeletion})")
+    stash.setProgressBarIter(qtyResults)
    for scene in scenes:
        QtyDup += 1
-        prgs = QtyDup / qtyResults
        stash.progressBar(QtyDup, qtyResults)
        # scene = stash.find_scene(sceneID['id'])
        # if scene == None or len(scene) == 0:
@@ -537,8 +634,15 @@ def manageTagggedDuplicates(clearTag=False):
            # continue
        # stash.Trace(f"scene={scene}")
        if clearTag:
-            QtyClearedTags += 1            
-            tags = [int(item['id']) for item in scene["tags"] if item['id'] != tagId]
+            QtyClearedTags += 1 
+            # ToDo: Add logic to exclude graylistMarkForDeletion
+            tags = [int(item['id']) for item in scene["tags"] if item['name'] not in excludedTags]
+            # if clearAllDupfileManagerTags:
+                # tags = []
+                # for tag in scene["tags"]:
+                    # if tag['name'] in excludedTags:
+                        # continue
+                    # tags += [int(tag['id'])]
            stash.TraceOnce(f"tagId={tagId}, len={len(tags)}, tags = {tags}")
            dataDict = {'id' : scene['id']}
            if addPrimaryDupPathToDetails:
@@ -549,10 +653,17 @@ def manageTagggedDuplicates(clearTag=False):
                    sceneDetails = sceneDetails[0:Pos1] + sceneDetails[Pos2 + len(detailPostfix):]                
                dataDict.update({'details' : sceneDetails})
            dataDict.update({'tag_ids' : tags})
-            stash.Log(f"Updating scene with {dataDict};QtyClearedTags={QtyClearedTags}")
-            stash.update_scene(dataDict)
+            stash.Log(f"Updating scene with {dataDict};QtyClearedTags={QtyClearedTags};Count={QtyDup} of {qtyResults}")
+            stash.updateScene(dataDict)
            # stash.removeTag(scene, duplicateMarkForDeletion)
-        else:
+        elif setGrayListTag:
+            if stash.startsWithInList(graylist, scene['files'][0]['path']):
+                QtySetGraylistTag+=1
+                if stash.addTag(scene, graylistMarkForDeletion, ignoreAutoTag=True):
+                    stash.Log(f"Added tag {graylistMarkForDeletion} to scene {scene['files'][0]['path']};QtySetGraylistTag={QtySetGraylistTag};Count={QtyDup} of {qtyResults}")
+                else:
+                    stash.Trace(f"Scene already had tag {graylistMarkForDeletion}; {scene['files'][0]['path']}")
+        elif deleteScenes:
            DupFileName = scene['files'][0]['path']
            DupFileNameOnly = pathlib.Path(DupFileName).stem
            stash.Warn(f"Deleting duplicate '{DupFileName}'", toAscii=True, printTo=LOG_STASH_N_PLUGIN)
@@ -563,45 +674,65 @@ def manageTagggedDuplicates(clearTag=False):
                shutil.move(DupFileName, destPath)
            elif moveToTrashCan:
                sendToTrash(DupFileName)
-            result = stash.destroy_scene(scene['id'], delete_file=True)
+            result = stash.destroyScene(scene['id'], delete_file=True)
            QtyDeleted += 1
-            stash.Trace(f"destroy_scene result={result} for file {DupFileName};QtyDeleted={QtyDeleted}", toAscii=True)
-    stash.Log(f"QtyDup={QtyDup}, QtyClearedTags={QtyClearedTags}, QtyDeleted={QtyDeleted}, QtyFailedQuery={QtyFailedQuery}", printTo=LOG_STASH_N_PLUGIN)
-    if doNotGeneratePhash == False and clearTag == False:
+            stash.Debug(f"destroyScene result={result} for file {DupFileName};QtyDeleted={QtyDeleted};Count={QtyDup} of {qtyResults}", toAscii=True)
+        else:
+            stash.Error("manageTagggedDuplicates called with invlaid input arguments. Doing early exit.")
+            return
+    stash.Debug("#####################################################")
+    stash.Log(f"QtyDup={QtyDup}, QtyClearedTags={QtyClearedTags}, QtySetGraylistTag={QtySetGraylistTag}, QtyDeleted={QtyDeleted}, QtyFailedQuery={QtyFailedQuery}", printTo=LOG_STASH_N_PLUGIN)
+    killScanningJobs()
+    # if doNotGeneratePhash == False and clearTag == False:
+        # stash.metadata_generate({"phashes": True})
+
+try:
+    if stash.PLUGIN_TASK_NAME == "tag_duplicates_task":
+        mangeDupFiles(tagDuplicates=True, merge=mergeDupFilename)
+        stash.Debug(f"{stash.PLUGIN_TASK_NAME} EXIT")
+    elif stash.PLUGIN_TASK_NAME == "delete_tagged_duplicates_task":
+        manageTagggedDuplicates(deleteScenes=True)
+        stash.Debug(f"{stash.PLUGIN_TASK_NAME} EXIT")
+    elif stash.PLUGIN_TASK_NAME == "delete_duplicates_task":
+        mangeDupFiles(deleteDup=True, merge=mergeDupFilename)
+        stash.Debug(f"{stash.PLUGIN_TASK_NAME} EXIT")
+    elif stash.PLUGIN_TASK_NAME == "clear_duplicate_tags_task":
+        manageTagggedDuplicates(clearTag=True)
+        stash.Debug(f"{stash.PLUGIN_TASK_NAME} EXIT")
+    elif stash.PLUGIN_TASK_NAME == "graylist_tag_task":
+        manageTagggedDuplicates(setGrayListTag=True)
+        stash.Debug(f"{stash.PLUGIN_TASK_NAME} EXIT")
+    elif stash.PLUGIN_TASK_NAME == "generate_phash_task":
        stash.metadata_generate({"phashes": True})
-
-if stash.PLUGIN_TASK_NAME == "tag_duplicates_task":
-    mangeDupFiles(tagDuplicates=True, merge=mergeDupFilename)
-    stash.Trace(f"{stash.PLUGIN_TASK_NAME} EXIT")
-elif stash.PLUGIN_TASK_NAME == "delete_tagged_duplicates_task":
-    manageTagggedDuplicates()
-    stash.Trace(f"{stash.PLUGIN_TASK_NAME} EXIT")
-elif stash.PLUGIN_TASK_NAME == "delete_duplicates_task":
-    mangeDupFiles(deleteDup=True, merge=mergeDupFilename)
-    stash.Trace(f"{stash.PLUGIN_TASK_NAME} EXIT")
-elif stash.PLUGIN_TASK_NAME == "clear_duplicate_tags_task":
-    manageTagggedDuplicates(clearTag=True)
-    stash.Trace(f"{stash.PLUGIN_TASK_NAME} EXIT")
-elif stash.PLUGIN_TASK_NAME == "generate_phash_task":
-    stash.metadata_generate({"phashes": True})
-    stash.Trace(f"{stash.PLUGIN_TASK_NAME} EXIT")
-elif parse_args.dup_tag:
-    mangeDupFiles(tagDuplicates=True, merge=mergeDupFilename)
-    stash.Trace(f"Tag duplicate EXIT")
-elif parse_args.del_tag:
-    manageTagggedDuplicates()
-    stash.Trace(f"Delete Tagged duplicates EXIT")
-elif parse_args.clear_tag:
-    manageTagggedDuplicates(clearTag=True)
-    stash.Trace(f"Clear duplicate tags EXIT")
-elif parse_args.remove:
-    mangeDupFiles(deleteDup=True, merge=mergeDupFilename)
-    stash.Trace(f"Delete duplicate EXIT")
-else:
-    stash.Log(f"Nothing to do!!! (PLUGIN_ARGS_MODE={stash.PLUGIN_TASK_NAME})")
+        stash.Debug(f"{stash.PLUGIN_TASK_NAME} EXIT")
+    elif parse_args.dup_tag:
+        stash.PLUGIN_TASK_NAME = "dup_tag"
+        mangeDupFiles(tagDuplicates=True, merge=mergeDupFilename)
+        stash.Debug(f"Tag duplicate EXIT")
+    elif parse_args.del_tag:
+        stash.PLUGIN_TASK_NAME = "del_tag"
+        manageTagggedDuplicates(deleteScenes=True)
+        stash.Debug(f"Delete Tagged duplicates EXIT")
+    elif parse_args.clear_tag:
+        stash.PLUGIN_TASK_NAME = "clear_tag"
+        manageTagggedDuplicates(clearTag=True)
+        stash.Debug(f"Clear duplicate tags EXIT")
+    elif parse_args.remove:
+        stash.PLUGIN_TASK_NAME = "remove"
+        mangeDupFiles(deleteDup=True, merge=mergeDupFilename)
+        stash.Debug(f"Delete duplicate EXIT")
+    else:
+        stash.Log(f"Nothing to do!!! (PLUGIN_ARGS_MODE={stash.PLUGIN_TASK_NAME})")
+except Exception as e:
+    tb = traceback.format_exc()
+    
+    stash.Error(f"Exception while running DupFileManager Task({stash.PLUGIN_TASK_NAME}); Error: {e}\nTraceBack={tb}")
+    killScanningJobs()
+    stash.convertToAscii = False
+    stash.Error(f"Error: {e}\nTraceBack={tb}")





-stash.Trace("\n*********************************\nEXITING   ***********************\n*********************************")
+stash.Log("\n*********************************\nEXITING   ***********************\n*********************************")