ReadMe for New interface

Author: AlbanP

Noema/conditionnal.py

@@ -74,6 +74,7 @@ def execute(self, state):
                     outputs.append(step.execute(state))
                     state.set_prop(step.name,outputs[-1])
                     prop_to_remove.append(step.name)
-                    
-        for prop in prop_to_remove:
-            state.set_prop(prop,None)
+          
+        # TODO: think about the variable scope. Should we remove the variables created in the IF block?          
+        # for prop in prop_to_remove:
+        #     state.set_prop(prop,None)

Noema/debug.py

@@ -10,10 +10,10 @@ def __init__(self, value):
     def execute(self, state):
         if isinstance(self.value, str):
             extracted = self.extract_variables_from_string(self.value, state)
-            print("DEBUG:",extracted)
+            print(extracted)
         elif isinstance(self.value, Step):
             extracted = self.value.execute(state)
-            print("DEBUG:",extracted)
+            print(extracted)
         else:
             raise ValueError("The parameter must be a string (state key) or a Step.")
 

Noema/generators.py

@@ -6,18 +6,22 @@
 
 class Select(GenStep):
 
-    def __init__(self, llm_input:str, options, to:str , action=None):
-        super().__init__(llm_input, to, output_type="Single Word",action=action)
-        if isinstance(options, str):
-            if not re.match(r'\{(\w+)\}', options):
-                raise ValueError(f"La source de donnée {options} doit être une variable entre accolades.")
-            self.options = re.findall(r'\{(\w+)\}', options)[0]
+    def __init__(self, **kwargs):
+        if len(kwargs) != 2:
+            raise ValueError("Var must have 2 arguments, datasource and options.")
+        dest = list(kwargs.keys())[0]
+        value = list(kwargs.values())[0]
+        options = list(kwargs.values())[1]
+        super().__init__(value, dest, output_type="Single Word")
+        
+        if callable(options):
+            self.options = options
         elif isinstance(options, list):
             self.options = options
         elif isinstance(options, Step):
             self.options = options
         else:
-            raise ValueError("The parameter must be a string (state key), a list or a Step.")
+            raise ValueError("The parameter must be a lambda function, a list or a Step.")
         self.display_type = "You respond by selecting the correct option."
 
     def execute(self, state):
@@ -27,12 +31,11 @@ def execute(self, state):
         llm += self.display_step_name + self.current_llm_input+ " " + select(current_options, name="response")
         res = llm["response"]
         state.llm += self.display_step_name + res + "\n" 
-        state.set(self.name, res)
         return res
 
     def resolve_param(self, param, state):
-        if isinstance(param, str):
-            return state.get(param)
+        if callable(param):
+            return param()
         elif isinstance(param, Step):
             return param.execute(state)
         elif isinstance(param, list):

Noema/horizon.py

@@ -1,4 +1,5 @@
 from .step import DebugStep, FlowStep, GenStep
+from .subject import Subject
 from .var import Var
 
 

Noema/information.py

@@ -2,22 +2,20 @@
 
 class Information(Step):
 
-    def __init__(self, value:str, action=None):
-        super().__init__(name="Information: ", action=action)
+    def __init__(self, value:str):
+        super().__init__(name="Information: ")
         self.value = value
 
     def execute(self, state):
 
         if isinstance(self.value, str):
             current_value = self.extract_variables_from_string(self.value, state)
-            state.llm += current_value + "\n"
         elif isinstance(self.value, Step):
             current_value = self.value.execute(state)
-            state.llm += current_value + "\n"
         else:
             raise ValueError("The parameter must be a string (state key) or a Step.")
-        
+        state.llm += "#"+self.name.upper()+":"+ current_value + "\n"
         return current_value
 
     def list_steps(self,state):
-        return [self.name+" "+self.value] if self.should_include_in_list() else []
+        return ["#"+self.name.upper()+": "+self.value] if self.should_include_in_list() else []

Noema/loops.py

@@ -149,7 +149,6 @@ def evaluate_condition(self, state):
                 return False
         elif isinstance(self.condition, Step):
             res = self.condition.execute(state)
-            print(f"Condition result: {res}")
             return bool(res)
         else:
             raise ValueError("Condition must be either a lambda function or a Step.")

Noema/noesis.py

@@ -49,7 +49,6 @@ def execute_with_params(self, state, param_values):
         start_time = time.time()
         for i, param_name in enumerate(self.param_names):
             param_value = param_values[i]
-            print(f"Setting {param_name} to {param_value}")
             state.set_prop(param_name, param_value)
 
         current_noesis = self.buildNoesis(self.param_names, param_values, state)
@@ -61,7 +60,6 @@ def execute_with_params(self, state, param_values):
         for step in self.steps:
             if isinstance(step, Return):
                 output = step.execute(state)
-                print("IN RETURN")
                 state.set_prop(self.name, output)
                 break
             elif isinstance(step, FlowStep):
@@ -122,9 +120,7 @@ def __call__(self,*args, **kwargs):
         for key, value in kwargs.items():
             if key not in self.param_names:
                 raise ValueError(f"Invalid parameter name: {key}")
-            print(f"IN CALL: param {key} with {value}")
             param_values.append(value)
-        print(f"Param values: {param_values}")
         return self.execute_with_params(state, param_values)
 
 
@@ -161,7 +157,6 @@ def resolve_param(self, param, state):
 
     def execute(self, state, run_step = True):
         output = self.value()
-        print(f"Result of '{self.name}' is: {output}")
         state.llm += f"#{self.name.upper()}: {output}"+ "\n"
         state.set_prop(self.name, output)
         return output

Noema/step.py

@@ -21,7 +21,6 @@ def lookup_reference(match):
         def lookup_variable(match):
             var_name = match.group(1)
             value = state.get_prop(var_name)
-            print("Value: ", value)
             if value is not None:
                 return str(value)
             else:
@@ -35,7 +34,6 @@ def lookup_variable(match):
         if re.search(r'\{(\w+)\}', string):
             string = re.sub(r'(.*)\{(\w+)\}(.*)', r'\1\2\3', string)
 
-        print("String: ", string)
         return string
 
     def extract_variables_from_string(self, string, state, can_be_None = False):

Noema/subject.py

@@ -11,16 +11,15 @@ def __init__(self, llm_path):
         )
         self.noema = ""
 
-    def add(self, var):
-        var.execute(self)
+    def add(self,**kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
 
     def set_prop(self, name, value):
-        print(f"Setting prop: {name} to {value}")
         setattr(self, name, value)
 
     def get_prop(self, name):
         value = getattr(self, name, None)
-        print(f"Getting prop: {name} with value {value}")
         return value
 
     def set(self, key, value, extend = False):
@@ -57,7 +56,6 @@ def set(self, key, value, extend = False):
         else:
             if key not in self.data.keys():
                 self.data[key] = value 
-                print("New array added")
                 return
             if extend:
                 if isinstance(self.data[key], list):

Noema/var.py

@@ -24,9 +24,7 @@ def execute(self, state, run_step = True):
             value = self.value.execute(state)
         elif callable(self.value):
             if run_step:
-                print(f"RUNNING FUNCTION {self.value.__name__}")
                 value = self.value()
-                print(f"RUNNING FUNCTION {self.value.__name__} WITH VALUE {value}")
             else:
                 value = self.value
 

Noema/write.py

@@ -13,7 +13,6 @@ def __init__(self, value:str, var_name:str, extend:bool = False, action=None):
 
     def execute(self, state):
         current_value = self.extract_variables_from_string(self.value, state)
-        print(f"Writing {current_value} to {self.name}")
         state.set(self.name, current_value, self.extend)
         return current_value