edsl 0.1.47__py3-none-any.whl → 0.1.49__py3-none-any.whl

edsl/surveys/{Rule.py → rules/rule.py}

@@ -20,25 +20,23 @@ with a low (-1) priority.
 import ast
 import random
 from typing import Any, Union, List
+from collections import defaultdict
 
 
 # from rich import print
 from simpleeval import EvalWithCompoundTypes
 
-from edsl.exceptions.surveys import SurveyError
+from ..exceptions import SurveyError
 
-from edsl.exceptions.surveys import (
+from ..exceptions import (
     SurveyRuleCannotEvaluateError,
-    SurveyRuleCollectionHasNoRulesAtNodeError,
     SurveyRuleRefersToFutureStateError,
-    SurveyRuleReferenceInRuleToUnknownQuestionError,
     SurveyRuleSendsYouBackwardsError,
     SurveyRuleSkipLogicSyntaxError,
 )
-from edsl.surveys.base import EndOfSurvey
-from edsl.utilities.ast_utilities import extract_variable_names
-from edsl.utilities.remove_edsl_version import remove_edsl_version
 
+from ..base import EndOfSurvey
+from ...utilities import extract_variable_names, remove_edsl_version
 
 class QuestionIndex:
     def __set_name__(self, owner, name):
@@ -58,19 +56,11 @@ class QuestionIndex:
 
 
 class Rule:
-    """The Rule class defines a "rule" for determining the next question presented to an agent."""
+    """The Rule class defines a "rule" for determining the next question present."""
 
     current_q = QuestionIndex()
     next_q = QuestionIndex()
 
-    # Not implemented but nice to have:
-    # We could potentially use the question pydantic models to check for rule conflicts, as
-    # they define the potential trees through a survey.
-
-    # We could also use the AST to check for conflicts by inspecting the types of a rule.
-    # For example, if we know the answer to a question is a string, we could check that
-    # the expression only contains string comparisons.
-
     def __init__(
         self,
         current_q: int,
@@ -114,8 +104,6 @@ class Rule:
                 f"The expression {self.expression} is not valid Python syntax."
             )
 
-        # get the names of the variables in the expression
-        # e.g., q1 == 'yes' -> ['q1']
         extracted_question_names = extract_variable_names(self.ast_tree)
 
         # make sure all the variables in the expression are known questions
@@ -123,11 +111,6 @@ class Rule:
             assert all([q in question_name_to_index for q in extracted_question_names])
         except AssertionError:
             pass
-            # import warnings
-            # warnings.warn(f"There is an extracted field in the expression that is not a known question. It could be a scenario variable. That's fine! But it also could be a typo or mistake.")
-            # print(f"Question name to index: {question_name_to_index}")
-            # print(f"Extracted question names: {extracted_question_names}")
-            # raise SurveyRuleReferenceInRuleToUnknownQuestionError
 
         # get the indices of the questions mentioned in the expression
         self.named_questions_by_index = [
@@ -144,6 +127,16 @@ class Rule:
                     "A rule refers to a future question, the answer to which would not be available here."
                 )
                 raise SurveyRuleRefersToFutureStateError
+            
+        if (referenced_questions := self._prior_question_is_in_expression()) and not self._is_jinja2_expression():            #raise ValueError("This uses the old syntax!")
+            import warnings
+            old_expression = self.expression
+            for q in referenced_questions:
+                if q + ".answer" in self.expression:
+                    self.expression = self.expression.replace(q + ".answer", f"{{{{ {q}.answer }}}}")
+                else:
+                    self.expression = self.expression.replace(q, f"{{{{ {q}.answer }}}}")
+            warnings.warn(f"This uses the old syntax! Converting to Jinja2 style with {{ }}.\nOld expression: {old_expression}\nNew expression: {self.expression}")
 
     def _checks(self):
         pass
@@ -153,7 +146,7 @@ class Rule:
 
         >>> r = Rule.example()
         >>> r.to_dict()
-        {'current_q': 1, 'expression': "q1 == 'yes'", 'next_q': 2, 'priority': 0, 'question_name_to_index': {'q1': 1}, 'before_rule': False}
+        {'current_q': 1, 'expression': "{{ q1.answer }} == 'yes'", 'next_q': 2, 'priority': 0, 'question_name_to_index': {'q1': 1}, 'before_rule': False}
         """
         return {
             "current_q": self.current_q,
@@ -225,6 +218,14 @@ class Rule:
                 replacement = str(value)
             d[var] = replacement
         return d
+    
+    def _prior_question_is_in_expression(self) -> set:
+        """Check if the expression contains a reference to a prior question."""
+        return {q for q in self.question_name_to_index.keys() if q in self.expression}
+    
+    def _is_jinja2_expression(self):
+        """Check if the expression is a Jinja2 expression."""
+        return "{{" in self.expression and "}}" in self.expression
 
     def evaluate(self, current_info_env: dict[int, Any]):
         """Compute the value of the expression, given a dictionary of known questions answers.
@@ -234,27 +235,89 @@ class Rule:
         If the expression cannot be evaluated, it raises a CannotEvaluate exception.
 
         >>> r = Rule.example()
-        >>> r.evaluate({'q1' : 'yes'})
+        >>> r.evaluate({'q1.answer' : 'yes'})
         True
-        >>> r.evaluate({'q1' : 'no'})
+        >>> r.evaluate({'q1.answer' : 'no'})
         False
 
         >>> r = Rule.example(jinja2=True)
-        >>> r.evaluate({'q1' : 'yes'})
+        >>> r.evaluate({'q1.answer' : 'yes'})
         True
 
         >>> r = Rule.example(jinja2=True)
-        >>> r.evaluate({'q1' : 'This is q1'})
+        >>> r.evaluate({'q1.answer' : 'This is q1'})
         False
 
-        >>> r = Rule.example(jinja2=False, bad = True)
-        >>> r.evaluate({'q1' : 'yes'})
-        Traceback (most recent call last):
-        ...
-        edsl.exceptions.surveys.SurveyRuleCannotEvaluateError...
+        >>> import warnings
+        >>> with warnings.catch_warnings(record=True) as w:
+        ...     expression = "q1 == 'yes'"
+        ...     r = Rule(current_q=1, expression=expression, next_q=2, question_name_to_index={"q1": 1}, priority=0)
+        ...     result = r.evaluate({'q1.answer' : 'yes'})
+        ...     assert len(w) == 1  # Verify warning was issued
+        ...     assert result == True
         """
         from jinja2 import Template
 
+        def jinja_ize_dictionary(dictionary):
+            """Convert a dictionary to a Jinja2 dictionary.
+            
+            Keys must be either:
+            - 'agent'
+            - 'scenario'
+            - A valid question name from question_name_to_index
+            
+            For question keys, the value is wrapped in an 'answer' subdictionary.
+            
+            Examples:
+            >>> d = jinja_ize_dictionary({'q1': 'yes'}, {'q1': 1})
+            >>> d['q1']['answer']
+            'yes'
+            
+            >>> d = jinja_ize_dictionary({'agent': 'friendly'}, {'q1': 1})
+            >>> d['agent']
+            'friendly'            
+            """
+            jinja_dict = defaultdict(dict)
+            
+            for key, value in dictionary.items():
+                # print("Now processing key: ", key)
+                # print(f"key: {key}, value: {value}")
+                # Handle special keys
+                if 'agent.' in key:
+                    # print("Agent key found")
+                    jinja_dict['agent'][key.split('.')[1]] = value
+                    # print("jinja dict: ", jinja_dict)
+                    continue 
+
+                if 'scenario.' in key:
+                    # print("Scenario key found")
+                    jinja_dict['scenario'][key.split('.')[1]] = value
+                    # print("jinja dict: ", jinja_dict)
+                    continue
+
+                # print("On to question keys")
+                for question_name in self.question_name_to_index.keys():
+                    # print("question_name: ", question_name)
+                    if question_name in key:
+                        if question_name == key:
+                            # print("question name is key; it's an answer")
+                            jinja_dict[question_name]['answer'] = value
+                            # print("jinja dict: ", jinja_dict)
+                            continue
+                        else:
+                            # print("question name is not key; it's a sub-type")
+                            if "." in key:
+                                passed_name, value_type = key.split('.')
+                                # print("passed_name: ", passed_name)
+                                # print("value_type: ", value_type)
+                                if passed_name == question_name:
+                                    # print("passed name is question name; it's a sub-type")
+                                    jinja_dict[question_name][value_type] = value
+                                    # print("jinja dict: ", jinja_dict)
+                                    continue
+                  
+            return jinja_dict
+
         def substitute_in_answers(expression, current_info_env):
             """Take the dictionary of answers and substitute them into the expression."""
 
@@ -262,19 +325,16 @@ class Rule:
 
             if "{{" in expression and "}}" in expression:
                 template_expression = Template(self.expression)
-                to_evaluate = template_expression.render(current_info)
+                jinja_dict = jinja_ize_dictionary(current_info)
+                to_evaluate = template_expression.render(jinja_dict)
             else:
-                # import warnings
-                # import textwrap
-                # warnings.warn(textwrap.dedent("""\
-                # The expression is not a Jinja2 template with {{ }}. This is not recommended.
-                # You can re-write your expression say "q1 == 'yes'" as "{{ q1 }} == 'yes'".
-                # """))
                 to_evaluate = expression
                 for var, value in current_info.items():
                     to_evaluate = to_evaluate.replace(var, value)
 
             return to_evaluate
+        
+        #breakpoint()
 
         try:
             to_evaluate = substitute_in_answers(self.expression, current_info_env)
@@ -300,16 +360,16 @@ class Rule:
     def example(cls, jinja2=False, bad=False):
         if jinja2:
             # a rule written in jinja2 style with {{ }}
-            expression = "{{ q1 }} == 'yes'"
+            expression = "{{ q1.answer }} == 'yes'"
         else:
-            expression = "q1 == 'yes'"
+            expression = "{{ q1.answer }} == 'yes'"
 
         if bad and jinja2:
             # a rule written in jinja2 style with {{ }} but with a 'bad' expression
             expression = "{{ q1 }} == 'This is q1'"
 
         if bad and not jinja2:
-            expression = "q1 == 'This is q1'"
+            expression = "{{ q1.answer }} == 'This is q1'"
 
         r = Rule(
             current_q=1,

edsl/surveys/{RuleCollection.py → rules/rule_collection.py}

@@ -3,15 +3,14 @@
 from typing import List, Union, Any, Optional
 from collections import defaultdict, UserList, namedtuple
 
-from edsl.exceptions.surveys import (
+from ..exceptions import (
     SurveyRuleCannotEvaluateError,
     SurveyRuleCollectionHasNoRulesAtNodeError,
 )
 
-from edsl.surveys.Rule import Rule
-from edsl.surveys.base import EndOfSurvey
-from edsl.surveys.DAG import DAG
-
+from .rule import Rule
+from ..base import EndOfSurvey
+from ..dag import DAG
 
 NextQuestion = namedtuple(
     "NextQuestion", "next_q, num_rules_found, expressions_evaluating_to_true, priority"
@@ -45,7 +44,7 @@ class RuleCollection(UserList):
 
     def to_dataset(self):
         """Return a Dataset object representation of the RuleCollection object."""
-        from edsl.results.Dataset import Dataset
+        from ...dataset import Dataset
 
         keys = ["current_q", "expression", "next_q", "priority", "before_rule"]
         rule_list = {}
@@ -56,13 +55,21 @@ class RuleCollection(UserList):
         return Dataset([{k: v} for k, v in rule_list.items()])
 
     def _repr_html_(self):
-        """Return an HTML representation of the RuleCollection object."""
-        from edsl.results.Dataset import Dataset
-
+        """Return an HTML representation of the RuleCollection object.
+        
+        >>> rule_collection = RuleCollection.example()
+        >>> _ = rule_collection._repr_html_()
+        """
         return self.to_dataset()._repr_html_()
 
     def to_dict(self, add_edsl_version=True):
-        """Create a dictionary representation of the RuleCollection object."""
+        """Create a dictionary representation of the RuleCollection object.
+        >>> rule_collection = RuleCollection.example()
+        >>> rule_collection_dict = rule_collection.to_dict()
+        >>> new_rule_collection = RuleCollection.from_dict(rule_collection_dict)
+        >>> repr(new_rule_collection) == repr(rule_collection)
+        True
+        """
         return {
             "rules": [rule.to_dict() for rule in self],
             "num_questions": self.num_questions,
@@ -108,18 +115,6 @@ class RuleCollection(UserList):
 
     def show_rules(self) -> None:
         """Print the rules in a table.
-
-
-        .. code-block:: python
-
-        rule_collection = RuleCollection.example()
-        rule_collection.show_rules()
-        ┏━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━┓
-        ┃ current_q ┃ expression  ┃ next_q ┃ priority ┃ before_rule ┃
-        ┡━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━┩
-        │ 1         │ q1 == 'yes' │ 3      │ 1        │ False       │
-        │ 1         │ q1 == 'no'  │ 2      │ 1        │ False       │
-        └───────────┴─────────────┴────────┴──────────┴─────────────┘
         """
         return self.to_dataset()
 
@@ -140,7 +135,6 @@ class RuleCollection(UserList):
         >>> rule_collection.add_rule(r)
         >>> rule_collection.skip_question_before_running(1, {})
         False
-
         """
         for rule in self.applicable_rules(q_now, before_rule=True):
             if rule.evaluate(answers):
@@ -157,7 +151,7 @@ class RuleCollection(UserList):
 
         >>> rule_collection = RuleCollection.example()
         >>> rule_collection.applicable_rules(1)
-        [Rule(current_q=1, expression="q1 == 'yes'", next_q=3, priority=1, question_name_to_index={'q1': 1, 'q2': 2, 'q3': 3, 'q4': 4}, before_rule=False), Rule(current_q=1, expression="q1 == 'no'", next_q=2, priority=1, question_name_to_index={'q1': 1, 'q2': 2, 'q3': 3, 'q4': 4}, before_rule=False)]
+        [Rule(current_q=1, expression="{{ q1.answer }} == 'yes'", next_q=3, priority=1, question_name_to_index={'q1': 1, 'q2': 2, 'q3': 3, 'q4': 4}, before_rule=False), Rule(current_q=1, expression="{{ q1.answer }} == 'no'", next_q=2, priority=1, question_name_to_index={'q1': 1, 'q2': 2, 'q3': 3, 'q4': 4}, before_rule=False)]
 
         The default is that the rule is applied after the question is asked.
         If we want to see the rules that apply before the question is asked, we can set before_rule=True.
@@ -189,7 +183,7 @@ class RuleCollection(UserList):
         :param answers: The answers to the survey questions so far, including the current question.
 
         >>> rule_collection = RuleCollection.example()
-        >>> rule_collection.next_question(1, {'q1': 'yes'})
+        >>> rule_collection.next_question(1, {'q1.answer': 'yes'})
         NextQuestion(next_q=3, num_rules_found=2, expressions_evaluating_to_true=1, priority=1)
 
         """
@@ -361,14 +355,14 @@ class RuleCollection(UserList):
             rules=[
                 Rule(
                     current_q=1,
-                    expression="q1 == 'yes'",
+                    expression="{{ q1.answer }} == 'yes'",
                     next_q=3,
                     priority=1,
                     question_name_to_index=qn2i,
                 ),
                 Rule(
                     current_q=1,
-                    expression="q1 == 'no'",
+                    expression="{{ q1.answer }} == 'no'",
                     next_q=2,
                     priority=1,
                     question_name_to_index=qn2i,
@@ -379,7 +373,4 @@ class RuleCollection(UserList):
 
 if __name__ == "__main__":
     import doctest
-
     doctest.testmod(optionflags=doctest.ELLIPSIS)
-
-    print(RuleCollection.example()._repr_html_())

edsl/surveys/{RuleManager.py → rules/rule_manager.py}

@@ -1,12 +1,12 @@
 from typing import Union, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from edsl.questions.QuestionBase import QuestionBase
-
-from edsl.surveys.Rule import Rule
-from .base import RulePriority, EndOfSurvey
-from edsl.exceptions.surveys import SurveyError, SurveyCreationError
+    from ...questions import QuestionBase
+    from ..survey import Survey
 
+from ..exceptions import SurveyError, SurveyCreationError
+from .rule import Rule
+from ..base import RulePriority, EndOfSurvey
 
 class ValidatedString(str):
     def __new__(cls, content):
@@ -22,8 +22,8 @@ class RuleManager:
         self.survey = survey
 
     def _get_question_index(
-        self, q: Union["QuestionBase", str, EndOfSurvey.__class__]
-    ) -> Union[int, EndOfSurvey.__class__]:
+        self, q: Union["QuestionBase", str, 'EndOfSurvey']
+    ) -> Union[int, 'EndOfSurvey']:
         """Return the index of the question or EndOfSurvey object.
 
         :param q: The question or question name to get the index of.
@@ -41,7 +41,7 @@ class RuleManager:
         >>> s._get_question_index("poop")
         Traceback (most recent call last):
         ...
-        edsl.exceptions.surveys.SurveyError: Question name poop not found in survey. The current question names are {'q0': 0, 'q1': 1, 'q2': 2}.
+        edsl.surveys.exceptions.SurveyError: Question name poop not found in survey. The current question names are {'q0': 0, 'q1': 1, 'q2': 2}.
         ...
         """
         if q == EndOfSurvey:
@@ -141,19 +141,19 @@ class RuleManager:
         Here, answering "yes" to q0 ends the survey:
 
         >>> from edsl import Survey
-        >>> s = Survey.example().add_stop_rule("q0", "q0 == 'yes'")
-        >>> s.next_question("q0", {"q0": "yes"})
+        >>> s = Survey.example().add_stop_rule("q0", "{{ q0.answer }} == 'yes'")
+        >>> s.next_question("q0", {"q0.answer": "yes"})
         EndOfSurvey
 
         By comparison, answering "no" to q0 does not end the survey:
 
-        >>> s.next_question("q0", {"q0": "no"}).question_name
+        >>> s.next_question("q0", {"q0.answer": "no"}).question_name
         'q1'
 
-        >>> s.add_stop_rule("q0", "q1 <> 'yes'")
+        >>> s.add_stop_rule("q0", "{{ q1.answer }} <> 'yes'")
         Traceback (most recent call last):
         ...
-        edsl.exceptions.surveys.SurveyCreationError: The expression contains '<>', which is not allowed. You probably mean '!='.
+        edsl.surveys.exceptions.SurveyCreationError: The expression contains '<>', which is not allowed. You probably mean '!='.
         ...
         """
         expression = ValidatedString(expression)
@@ -170,3 +170,9 @@ class RuleManager:
             )
         self.survey.add_rule(question, expression, EndOfSurvey)
         return self.survey
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)