From a57efc2012f1818c11ccb88f3804cd119767d717 Mon Sep 17 00:00:00 2001
From: Lyncoln <arcticfoxx_dlf@hotmail.com>
Date: Wed, 21 Oct 2026 00:27:21 -0400
Subject: [PATCH] Apply conditions included in action runtime. Actions now
 decide their own execution conditions

---
 core/execution/action/action.py       | 18 ++++++-----
 core/execution/operation/operation.py | 10 ++-----
 core/runtime/applyconditions.py       | 43 +++++++++++++--------------
 3 files changed, 34 insertions(+), 37 deletions(-)

diff --git a/core/execution/action/action.py b/core/execution/action/action.py
index 99bb34d..9f5851a 100644
--- a/core/execution/action/action.py
+++ b/core/execution/action/action.py
@@ -3,7 +3,6 @@ from core.runtime.runtimecontract import buildRuntimeAttr, buildPreRuntimeAttr
 
 
 def buildAction (action, outputs):
-    #outputs, resolved = buildPreRuntimeAttr(action, outputs)
 
     if hasattr(action, "recursive"):
         recursiveresponses = []
@@ -15,19 +14,24 @@ def buildAction (action, outputs):
 
         for item in items:
             outputs[action.recursive["label"]] = item
+            outputs, resolved, match, filter = buildPreRuntimeAttr(action, outputs)
 
-            outputs, resolved = buildPreRuntimeAttr(action, outputs)
-
+            if match:
+                continue
+            
             response, outputs = executeRequest(action, outputs, resolved)
             recursiveresponses.append(response)
-    
             outputs, response = buildRuntimeAttr(action, outputs, resolved, response)
 
-        return outputs, recursiveresponses
+        return outputs, recursiveresponses, match, filter
 
     else:
-        outputs, resolved = buildPreRuntimeAttr(action, outputs)
+        outputs, resolved, match, filter = buildPreRuntimeAttr(action, outputs)
+
+        if match:
+            return outputs, resolved, match, filter
+
         response, outputs = executeRequest(action, outputs, resolved)    
         outputs, response = buildRuntimeAttr(action, outputs, resolved, response)
 
-    return outputs, response
+    return outputs, response, match, filter
diff --git a/core/execution/operation/operation.py b/core/execution/operation/operation.py
index aa3e587..0430432 100644
--- a/core/execution/operation/operation.py
+++ b/core/execution/operation/operation.py
@@ -8,24 +8,18 @@ outputs = {}
 def buildOperation(definition, outputs):
     actions = definition.actions
     responses = []
-    #outputs = {}
 
     for action in actions:
 
-        if skipStep(definition, action, outputs):
-            continue
 
         if action == "recursiveset":
             outputs, responses = recursiveSet(definition, outputs, responses)
 
         else:
-            outputs, response = buildAction(action, outputs)
+            outputs, response, match, filter = buildAction(action, outputs)
+
             responses.append(response)
 
-        
-        #print("DEBUG ID GRAB. CHECK LASTMESSAGES")
-        #print(outputs)
-        #print(responses)
 
         #except Exception as error:
             #outputs = manageFailure(error, action, outputs)
diff --git a/core/runtime/applyconditions.py b/core/runtime/applyconditions.py
index 1e58913..9c56e21 100644
--- a/core/runtime/applyconditions.py
+++ b/core/runtime/applyconditions.py
@@ -1,58 +1,57 @@
 def applyConditions(definition, dictionary, outputs):
     if hasattr(definition, "filters"):
-        #print("DEBUG DICTIONARY PASS")
-        #print(dictionary)
-        for filter in definition.filters:
-            #print(filter)
-            try:
-                if isinstance(filter["filtervalue"], dict):
-                    #print("DEBUGGING INT ERROR")
-                    #print(filter["filtervalue"])
-                    resolvedoutput = outputs[filter["filtervalue"]["outputs"]]
-                    #print(resolvedoutput)
-                    #filter["filtervalue"] = outputs[filter["filtervalue"]["outputs"]]
-                    #print(outputs[filter["filtervalue"]["outputs"]])
-                    filter["filtervalue"] = resolvedoutput
 
+        for filter in definition.filters:
+            try:
+                filtervalue = filter["filtervalue"]
+                if isinstance(filter["filtervalue"], dict):
+
+                    filtervalue = outputs[filtervalue["outputs"]]
                     
                 if filter["operator"] == ">=":
-                    if dictionary.get(filter["filterkey"]) >= filter["filtervalue"]:
+                    if dictionary.get(filter["filterkey"]) >= int(filtervalue):
                         print(filter["print"])
                         return True, filter
 
                 if filter["operator"] == "<=":
-                    if dictionary.get(filter["filterkey"]) <= filter["filtervalue"]:
+                    if dictionary.get(filter["filterkey"]) <= int(filtervalue):
                         print(filter["print"])
                         return True, filter
 
                 if filter["operator"] == "==":
-                    if dictionary.get(filter["filterkey"]) == filter["filtervalue"]:
+                    if dictionary.get(filter["filterkey"]) == filtervalue:
                         print(filter["print"])
                         return True, filter
 
                 if filter["operator"] == "!=":
-                    if dictionary.get(filter["filterkey"]) != filter["filtervalue"]:
+                    if dictionary.get(filter["filterkey"]) != filtervalue:
                         print(filter["print"])
                         return True, filter
 
                 if filter["operator"] == ">":
-                    if dictionary.get(filter["filterkey"]) > filter["filtervalue"]:
+                    if dictionary.get(filter["filterkey"]) > int(filtervalue):
                         print(filter["print"])
                         return True, filter
 
                 if filter["operator"] == "<":
-                    if dictionary.get(filter["filterkey"]) < filter["filtervalue"]:
+                    if dictionary.get(filter["filterkey"]) < int(filtervalue):
                         print(filter["print"])
                         return True, filter
 
                 if filter["operator"] == "in":
-                    if filter["filtervalue"] in dictionary:
+                    if filtervalue in dictionary:
                         print(filter["print"])
                         return True, filter
 
             except KeyError:
-                print("Recording last unread for future checks")
-                continue
+                print("Value not present")
+                print(filter)
+                return True, filter
+                #continue
+
+            #except TypeError:
+            #    print("TypeError")
+            #    return False, None
             
     return False, None