edsl 0.1.44__py3-none-any.whl → 0.1.45__py3-none-any.whl

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.44"
+__version__ = "0.1.45"

edsl/agents/InvigilatorBase.py

@@ -74,7 +74,7 @@ class InvigilatorBase(ABC):
     @property
     def prompt_constructor(self) -> PromptConstructor:
         """Return the prompt constructor."""
-        return PromptConstructor(self, prompt_plan=self.prompt_plan)
+        return PromptConstructor.from_invigilator(self, prompt_plan=self.prompt_plan)
 
     def to_dict(self, include_cache=False) -> Dict[str, Any]:
         attributes = [
@@ -87,6 +87,7 @@ class InvigilatorBase(ABC):
             "iteration",
             "additional_prompt_data",
             "survey",
+            "raw_model_response",
         ]
         if include_cache:
             attributes.append("cache")
@@ -135,6 +136,7 @@ class InvigilatorBase(ABC):
         d["additional_prompt_data"] = data["additional_prompt_data"]
 
         d = cls(**d)
+        d.raw_model_response = data.get("raw_model_response")
         return d
 
     def __repr__(self) -> str:

edsl/agents/PromptConstructor.py

@@ -71,24 +71,49 @@ class PromptConstructor:
     - The question instructions - "You are being asked the following question: Do you like school? The options are 0: yes 1: no Return a valid JSON formatted like this, selecting only the number of the option: {"answer": <put answer code here>, "comment": "<put explanation here>"} Only 1 option may be selected."
     - The memory prompt - "Before the question you are now answering, you already answered the following question(s): Question: Do you like school? Answer: Prior answer"
     """
+    @classmethod
+    def from_invigilator(
+        cls,
+        invigilator: "InvigilatorBase",
+        prompt_plan: Optional["PromptPlan"] = None
+    ) -> "PromptConstructor":
+        return cls(
+            agent=invigilator.agent,
+            question=invigilator.question,
+            scenario=invigilator.scenario,
+            survey=invigilator.survey,
+            model=invigilator.model,
+            current_answers=invigilator.current_answers,
+            memory_plan=invigilator.memory_plan,
+            prompt_plan=prompt_plan
+        )
 
     def __init__(
-        self, invigilator: "InvigilatorBase", prompt_plan: Optional["PromptPlan"] = None
+        self,
+        agent: "Agent",
+        question: "QuestionBase",
+        scenario: "Scenario",
+        survey: "Survey",
+        model: "LanguageModel",
+        current_answers: dict,
+        memory_plan: "MemoryPlan",
+        prompt_plan: Optional["PromptPlan"] = None
     ):
-        self.invigilator = invigilator
+        self.agent = agent
+        self.question = question
+        self.scenario = scenario
+        self.survey = survey
+        self.model = model
+        self.current_answers = current_answers
+        self.memory_plan = memory_plan
         self.prompt_plan = prompt_plan or PromptPlan()
 
-        self.agent = invigilator.agent
-        self.question = invigilator.question
-        self.scenario = invigilator.scenario
-        self.survey = invigilator.survey
-        self.model = invigilator.model
-        self.current_answers = invigilator.current_answers
-        self.memory_plan = invigilator.memory_plan
-
-    def get_question_options(self, question_data):
+    def get_question_options(self, question_data: dict) -> list[str]:
         """Get the question options."""
-        return QuestionOptionProcessor(self).get_question_options(question_data)
+        return (QuestionOptionProcessor
+                .from_prompt_constructor(self)
+                .get_question_options(question_data)
+        )
 
     @cached_property
     def agent_instructions_prompt(self) -> Prompt:
@@ -198,9 +223,10 @@ class PromptConstructor:
     @cached_property
     def question_file_keys(self) -> list:
         """Extracts the file keys from the question text.
+        
         It checks if the variables in the question text are in the scenario file keys.
         """
-        return QuestionTemplateReplacementsBuilder(self).question_file_keys()
+        return QuestionTemplateReplacementsBuilder.from_prompt_constructor(self).question_file_keys()
 
     @cached_property
     def question_instructions_prompt(self) -> Prompt:
@@ -219,7 +245,7 @@ class PromptConstructor:
             QuestionInstructionPromptBuilder,
         )
 
-        return QuestionInstructionPromptBuilder(self).build()
+        return QuestionInstructionPromptBuilder.from_prompt_constructor(self).build()
 
     @cached_property
     def prior_question_memory_prompt(self) -> Prompt:
@@ -287,30 +313,32 @@ class PromptConstructor:
         arranged = self.prompt_plan.arrange_components(**components)
         
         if parallel == "process":
-            ctx = get_context('fork')
-            with ctx.Pool() as pool:
-                results = pool.map(_process_prompt, [
-                    (arranged["user_prompt"], {}),
-                    (arranged["system_prompt"], {})
-                ])
-                prompts = {
-                    "user_prompt": results[0],
-                    "system_prompt": results[1]
-                }
+            pass
+            # ctx = get_context('fork')
+            # with ctx.Pool() as pool:
+            #     results = pool.map(_process_prompt, [
+            #         (arranged["user_prompt"], {}),
+            #         (arranged["system_prompt"], {})
+            #     ])
+            #     prompts = {
+            #         "user_prompt": results[0],
+            #         "system_prompt": results[1]
+            #     }
             
         elif parallel == "thread":
-            with ThreadPoolExecutor() as executor:
-                user_prompt_list = arranged["user_prompt"]
-                system_prompt_list = arranged["system_prompt"]
+            pass
+            # with ThreadPoolExecutor() as executor:
+            #     user_prompt_list = arranged["user_prompt"]
+            #     system_prompt_list = arranged["system_prompt"]
                 
-                # Process both prompt lists in parallel
-                rendered_user = executor.submit(_process_prompt, (user_prompt_list, {}))
-                rendered_system = executor.submit(_process_prompt, (system_prompt_list, {}))
+            #     # Process both prompt lists in parallel
+            #     rendered_user = executor.submit(_process_prompt, (user_prompt_list, {}))
+            #     rendered_system = executor.submit(_process_prompt, (system_prompt_list, {}))
                 
-                prompts = {
-                    "user_prompt": rendered_user.result(),
-                    "system_prompt": rendered_system.result()
-                }
+            #     prompts = {
+            #         "user_prompt": rendered_user.result(),
+            #         "system_prompt": rendered_system.result()
+            #     }
                 
         else:  # sequential processing
             prompts = self.prompt_plan.get_prompts(**components)

edsl/agents/QuestionInstructionPromptBuilder.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Set
+from typing import Dict, List, Set, Any, Union
 from warnings import warn
 import logging
 from edsl.prompts.Prompt import Prompt
@@ -11,97 +11,150 @@ from edsl.agents.QuestionTemplateReplacementsBuilder import (
 class QuestionInstructionPromptBuilder:
     """Handles the construction and rendering of question instructions."""
 
-    def __init__(self, prompt_constructor: "PromptConstructor"):
+    @classmethod
+    def from_prompt_constructor(cls, prompt_constructor: "PromptConstructor"):
+        
+        model = prompt_constructor.model
+        survey = prompt_constructor.survey
+        question = prompt_constructor.question
+        return cls(prompt_constructor, model, survey, question)
+
+    def __init__(self, prompt_constructor: "PromptConstructor", model:"Model", survey:"Survey", question:"QuestionBase"):
         self.prompt_constructor = prompt_constructor
+        self.model = model
+        self.survey = survey
+        self.question = question
+
+        self.scenario = prompt_constructor.scenario
+        self.prior_answers_dict = prompt_constructor.prior_answers_dict()
+
+        self.qtrb = QTRB.from_prompt_constructor(self.prompt_constructor)
 
-        self.model = self.prompt_constructor.model
-        self.survey = self.prompt_constructor.survey
-        self.question = self.prompt_constructor.question
 
     def build(self) -> Prompt:
         """Builds the complete question instructions prompt with all necessary components.
 
         Returns:
-            Prompt: The fully rendered question instructions
+            Prompt: The fully rendered question instructions to be send to the Language Model
+
+        >>> from edsl import QuestionMultipleChoice
+        >>> from edsl import Survey
+        >>> q = Survey.example().questions[0]
+        >>> from edsl import Model
+        >>> class FakePromptConstructor:
+        ...     def __init__(self, scenario, question, agent):
+        ...         self.scenario = scenario
+        ...         self.question = question
+        ...         self.agent = agent
+        ...         self.model = Model('test')
+        ...         self.survey = Survey.example()
+        ...     scenario = {"file1": "file1"}
+        ...     question = q
+        ...     agent = "agent"
+        ...     def prior_answers_dict(self):
+        ...         return {'q0': 'q0'}
+        >>> mpc = FakePromptConstructor(
+        ...     scenario={"file1": "file1"},
+        ...     question=q,
+        ...     agent="agent"
+        ... )
+        >>> qipb = QuestionInstructionPromptBuilder.from_prompt_constructor(mpc)
+        >>> qipb.build()
+        Prompt(text=\"""
+        Do you like school?
+        <BLANKLINE>
+        <BLANKLINE>
+        yes
+        <BLANKLINE>
+        no
+        <BLANKLINE>
+        <BLANKLINE>
+        Only 1 option may be selected.
+        <BLANKLINE>
+        Respond only with a string corresponding to one of the options.
+        <BLANKLINE>
+        <BLANKLINE>
+        After the answer, you can put a comment explaining why you chose that option on the next line.\""")
         """
-        import time
-        
-        start = time.time()
-        
         # Create base prompt
-        base_start = time.time()
         base_prompt = self._create_base_prompt()
-        base_end = time.time()
-        logging.debug(f"Time for base prompt: {base_end - base_start}")
         
         # Enrich with options
-        enrich_start = time.time()
-        enriched_prompt = self._enrich_with_question_options(base_prompt)
-        enrich_end = time.time()
-        logging.debug(f"Time for enriching with options: {enrich_end - enrich_start}")
+        enriched_prompt = self._enrich_with_question_options(prompt_data=base_prompt, scenario=self.scenario, prior_answers_dict=self.prior_answers_dict)
         
         # Render prompt
-        render_start = time.time()
         rendered_prompt = self._render_prompt(enriched_prompt)
-        render_end = time.time()
-        logging.debug(f"Time for rendering prompt: {render_end - render_start}")
         
         # Validate template variables
-        validate_start = time.time()
         self._validate_template_variables(rendered_prompt)
-        validate_end = time.time()
-        logging.debug(f"Time for template validation: {validate_end - validate_start}")
         
         # Append survey instructions
-        append_start = time.time()
         final_prompt = self._append_survey_instructions(rendered_prompt)
-        append_end = time.time()
-        logging.debug(f"Time for appending survey instructions: {append_end - append_start}")
-        
-        end = time.time()
-        logging.debug(f"Total time in build_question_instructions: {end - start}")
         
         return final_prompt
 
-    def _create_base_prompt(self) -> Dict:
+    def _create_base_prompt(self) -> Dict[str, Union[Prompt, Dict[str, Any]]]:
         """Creates the initial prompt with basic question data.
 
+        The data are, e.g., the question name, question text, question options, etc.
+
+        >>> from edsl import QuestionMultipleChoice
+        >>> QuestionMultipleChoice.example().data.copy()
+        {'question_name': 'how_feeling', 'question_text': 'How are you?', 'question_options': ['Good', 'Great', 'OK', 'Bad'], 'include_comment': False}
+
         Returns:
-            Dict: Base question data
+            Dict[str, Union[Prompt, Dict[str, Any]]]: Base question data with prompt and data fields
         """
         return {
             "prompt": Prompt(self.question.get_instructions(model=self.model.model)),
             "data": self.question.data.copy(),
         }
 
-    def _enrich_with_question_options(self, prompt_data: Dict) -> Dict:
-        """Enriches the prompt data with question options if they exist.
+    @staticmethod
+    def _process_question_options(question_data: Dict, scenario: 'Scenario', prior_answers_dict: Dict) -> Dict:
+        """Processes and replaces question options in the question data if they exist.
+
+        The question_options could be intended to be replaced with data from a scenario or prior answers.
+
+        >>> question_data = {'question_name': 'q0', 'question_text': 'Do you like school?', 'question_options': '{{ options }}'}
+        >>> scenario = {"options": ["yes", "no"]}
+        >>> prior_answers_dict = {}
+        >>> QuestionInstructionPromptBuilder._process_question_options(question_data, scenario, prior_answers_dict)
+        {'question_name': 'q0', 'question_text': 'Do you like school?', 'question_options': ['yes', 'no']}
 
         Args:
-            prompt_data: Dictionary containing prompt and question data
+            question_data: Dictionary containing question data
+            scenario: Scenario object
+            prior_answers_dict: Dictionary of prior answers
 
         Returns:
-            Dict: Enriched prompt data
+            Dict: Question data with processed question options
         """
-        import time
-        
-        start = time.time()
-        
-        if "question_options" in prompt_data["data"]:
+        if "question_options" in question_data:
             from edsl.agents.question_option_processor import QuestionOptionProcessor
             
-            processor_start = time.time()
-            question_options = QuestionOptionProcessor(
-                self.prompt_constructor
-            ).get_question_options(question_data=prompt_data["data"])
-            processor_end = time.time()
-            logging.debug(f"Time to process question options: {processor_end - processor_start}")
-            
-            prompt_data["data"]["question_options"] = question_options
+            question_options = (QuestionOptionProcessor(scenario, prior_answers_dict)
+                                .get_question_options(question_data=question_data)
+            )
+            question_data["question_options"] = question_options
             
-        end = time.time()
-        logging.debug(f"Total time in _enrich_with_question_options: {end - start}")
-        
+        return question_data
+
+    @staticmethod
+    def _enrich_with_question_options(prompt_data: Dict, scenario: 'Scenario', prior_answers_dict: Dict) -> Dict:
+        """Enriches the prompt data with processed question options if they exist.
+
+        Args:
+            prompt_data: Dictionary containing prompt and question data
+            scenario: Scenario object
+            prior_answers_dict: Dictionary of prior answers
+
+        Returns:
+            Dict: Enriched prompt data
+        """
+        prompt_data["data"] = QuestionInstructionPromptBuilder._process_question_options(
+            prompt_data["data"], scenario, prior_answers_dict
+        )
         return prompt_data
 
     def _render_prompt(self, prompt_data: Dict) -> Prompt:
@@ -113,28 +166,13 @@ class QuestionInstructionPromptBuilder:
         Returns:
             Prompt: Rendered instructions
         """
-        import time
-        
-        start = time.time()
-        
         # Build replacement dict
-        dict_start = time.time()
-        replacement_dict = QTRB(self.prompt_constructor).build_replacement_dict(
+        replacement_dict = self.qtrb.build_replacement_dict(
             prompt_data["data"]
         )
-        dict_end = time.time()
-        logging.debug(f"Time to build replacement dict: {dict_end - dict_start}")
         
         # Render with dict
-        render_start = time.time()
-        result = prompt_data["prompt"].render(replacement_dict)
-        render_end = time.time()
-        logging.debug(f"Time to render with dict: {render_end - render_start}")
-        
-        end = time.time()
-        logging.debug(f"Total time in _render_prompt: {end - start}")
-        
-        return result
+        return prompt_data["prompt"].render(replacement_dict)
 
     def _validate_template_variables(self, rendered_prompt: Prompt) -> None:
         """Validates that all template variables have been properly replaced.
@@ -185,3 +223,8 @@ class QuestionInstructionPromptBuilder:
             preamble += instruction.text
 
         return preamble + rendered_prompt
+
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

edsl/agents/QuestionTemplateReplacementsBuilder.py

@@ -4,19 +4,53 @@ from typing import Any, Set, TYPE_CHECKING
 if TYPE_CHECKING:
     from edsl.agents.PromptConstructor import PromptConstructor
     from edsl.scenarios.Scenario import Scenario
+    from edsl.questions.QuestionBase import QuestionBase
+    from edsl.agents.Agent import Agent
 
 
 class QuestionTemplateReplacementsBuilder:
-    def __init__(self, prompt_constructor: "PromptConstructor"):
-        self.prompt_constructor = prompt_constructor
+
+    @classmethod
+    def from_prompt_constructor(cls, prompt_constructor: "PromptConstructor"):
+        scenario = prompt_constructor.scenario
+        question = prompt_constructor.question
+        prior_answers_dict = prompt_constructor.prior_answers_dict()
+        agent = prompt_constructor.agent
+
+        return cls(scenario, question, prior_answers_dict, agent)
+
+    def __init__(
+        self,
+        scenario: "Scenario",
+        question: "QuestionBase",
+        prior_answers_dict: dict,
+        agent: "Agent",
+    ):
+        self.scenario = scenario
+        self.question = question
+        self.prior_answers_dict = prior_answers_dict
+        self.agent = agent
 
     def question_file_keys(self):
-        question_text = self.prompt_constructor.question.question_text
-        file_keys = self._find_file_keys(self.prompt_constructor.scenario)
+        """
+        >>> from edsl import QuestionMultipleChoice, Scenario
+        >>> q = QuestionMultipleChoice(question_text="Do you like school?", question_name = "q0", question_options = ["yes", "no"])
+        >>> qtrb = QuestionTemplateReplacementsBuilder(scenario = {"file1": "file1"}, question = q, prior_answers_dict = {'q0': 'q0'}, agent = "agent")
+        >>> qtrb.question_file_keys()
+        []
+        >>> from edsl import FileStore
+        >>> fs = FileStore.example()
+        >>> q = QuestionMultipleChoice(question_text="What do you think of this file: {{ file1 }}", question_name = "q0", question_options = ["good", "bad"])
+        >>> qtrb = QuestionTemplateReplacementsBuilder(scenario = Scenario({"file1": fs}), question = q, prior_answers_dict = {'q0': 'q0'}, agent = "agent")
+        >>> qtrb.question_file_keys()
+        ['file1']
+        """
+        question_text = self.question.question_text
+        file_keys = self._find_file_keys(self.scenario)
         return self._extract_file_keys_from_question_text(question_text, file_keys)
 
     def scenario_file_keys(self):
-        return self._find_file_keys(self.prompt_constructor.scenario)
+        return self._find_file_keys(self.scenario)
 
     def get_jinja2_variables(template_str: str) -> Set[str]:
         """
@@ -88,15 +122,17 @@ class QuestionTemplateReplacementsBuilder:
                 question_file_keys.append(var)
         return question_file_keys
 
-    def _scenario_replacements(self) -> dict[str, Any]:
+    def _scenario_replacements(
+        self, replacement_string: str = "<see file {key}>"
+    ) -> dict[str, Any]:
         # File references dictionary
-        file_refs = {key: f"<see file {key}>" for key in self.scenario_file_keys()}
+        file_refs = {
+            key: replacement_string.format(key=key) for key in self.scenario_file_keys()
+        }
 
         # Scenario items excluding file keys
         scenario_items = {
-            k: v
-            for k, v in self.prompt_constructor.scenario.items()
-            if k not in self.scenario_file_keys()
+            k: v for k, v in self.scenario.items() if k not in self.scenario_file_keys()
         }
         return {**file_refs, **scenario_items}
 
@@ -119,14 +155,31 @@ class QuestionTemplateReplacementsBuilder:
         return {**question_settings, **question_data}
 
     def build_replacement_dict(self, question_data: dict) -> dict[str, Any]:
-        """Builds a dictionary of replacement values for rendering a prompt by combining multiple data sources."""
+        """Builds a dictionary of replacement values for rendering a prompt by combining multiple data sources.
+
+
+        >>> from edsl import QuestionMultipleChoice, Scenario
+        >>> q = QuestionMultipleChoice(question_text="Do you like school?", question_name = "q0", question_options = ["yes", "no"])
+        >>> qtrb = QuestionTemplateReplacementsBuilder(scenario = {"file1": "file1"}, question = q, prior_answers_dict = {'q0': 'q0'}, agent = "agent")
+        >>> qtrb.question_file_keys()
+        []
+        >>> from edsl import FileStore
+        >>> fs = FileStore.example()
+        >>> s = Scenario({"file1": fs, "first_name": "John"})
+        >>> q = QuestionMultipleChoice(question_text="What do you think of this file: {{ file1 }}, {{ first_name}}", question_name = "q0", question_options = ["good", "bad"])
+        >>> qtrb = QuestionTemplateReplacementsBuilder(scenario = s, question = q, prior_answers_dict = {'q0': 'q0'}, agent = "agent")
+        >>> qtrb.build_replacement_dict(q.data)
+        {'file1': '<see file file1>', 'first_name': 'John', 'use_code': False, 'include_comment': True, 'question_name': 'q0', 'question_text': 'What do you think of this file: {{ file1 }}, {{ first_name}}', 'question_options': ['good', 'bad'], 'q0': 'q0', 'agent': 'agent'}
+
+
+        """
         rpl = {}
         rpl["scenario"] = self._scenario_replacements()
-        rpl["question"] = self._question_data_replacements(
-            self.prompt_constructor.question, question_data
-        )
-        rpl["prior_answers"] = self.prompt_constructor.prior_answers_dict()
-        rpl["agent"] = {"agent": self.prompt_constructor.agent}
+        rpl["question"] = self._question_data_replacements(self.question, question_data)
+        # rpl["prior_answers"] = self.prompt_constructor.prior_answers_dict()
+        rpl["prior_answers"] = self.prior_answers_dict
+        # rpl["agent"] = {"agent": self.prompt_constructor.agent}
+        rpl["agent"] = {"agent": self.agent}
 
         # Combine all dictionaries using dict.update() for clarity
         replacement_dict = {}

edsl/agents/question_option_processor.py

@@ -8,8 +8,16 @@ class QuestionOptionProcessor:
     These can be provided directly, as a template string, or fetched from prior answers or the scenario.
     """
 
-    def __init__(self, prompt_constructor):
-        self.prompt_constructor = prompt_constructor
+    @classmethod
+    def from_prompt_constructor(cls, prompt_constructor):
+        scenario = prompt_constructor.scenario
+        prior_answers_dict = prompt_constructor.prior_answers_dict()
+
+        return cls(scenario, prior_answers_dict)
+
+    def __init__(self, scenario: 'Scenario', prior_answers_dict: dict):
+        self.scenario = scenario 
+        self.prior_answers_dict = prior_answers_dict
 
     @staticmethod
     def _get_default_options() -> list:
@@ -109,7 +117,8 @@ class QuestionOptionProcessor:
         >>> mpc = MockPromptConstructor()
         >>> from edsl import Scenario
         >>> mpc.scenario = Scenario({"options": ["Option 1", "Option 2"]})
-        >>> processor = QuestionOptionProcessor(mpc)
+        >>> mpc.prior_answers_dict = lambda: {'q0': 'q0'}
+        >>> processor = QuestionOptionProcessor.from_prompt_constructor(mpc)
 
         The basic case where options are directly provided:
 
@@ -130,7 +139,7 @@ class QuestionOptionProcessor:
         >>> q0 = MockQuestion()
         >>> q0.answer = ["Option 1", "Option 2"]
         >>> mpc.prior_answers_dict = lambda: {'q0': q0}
-        >>> processor = QuestionOptionProcessor(mpc)
+        >>> processor = QuestionOptionProcessor.from_prompt_constructor(mpc)
         >>> question_data = {"question_options": "{{ q0 }}"}
         >>> processor.get_question_options(question_data)
         ['Option 1', 'Option 2']
@@ -151,14 +160,14 @@ class QuestionOptionProcessor:
 
         # Try getting options from scenario
         scenario_options = self._get_options_from_scenario(
-            self.prompt_constructor.scenario, option_key
+            self.scenario, option_key
         )
         if scenario_options:
             return scenario_options
 
         # Try getting options from prior answers
         prior_answer_options = self._get_options_from_prior_answers(
-            self.prompt_constructor.prior_answers_dict(), option_key
+            self.prior_answers_dict, option_key
         )
         if prior_answer_options:
             return prior_answer_options

edsl/coop/CoopFunctionsMixin.py

@@ -4,10 +4,9 @@ class CoopFunctionsMixin:
 
         s = Scenario({"existing_names": existing_names})
         q = QuestionList(
-            question_text="""The following colum names are already in use: {{ existing_names }} 
-                         Please provide new names for the columns.
-                         They should be short, one or two words, and unique. They should be valid Python idenifiers. 
-                         No spaces - use underscores instead. 
+            question_text="""The following column names are already in use: {{ existing_names }} 
+                         Please provide new column names.
+                         They should be short (one or two words) and unique valid Python idenifiers (i.e., use underscores instead of spaces). 
                          """,
             question_name="better_names",
         )