edsl 0.1.33.dev3__py3-none-any.whl → 0.1.34__py3-none-any.whl

edsl/Base.py

@@ -115,23 +115,27 @@ class PersistenceMixin:
         if filename.endswith("json.gz"):
             import warnings
 
-            warnings.warn(
-                "Do not apply the file extensions. The filename should not end with 'json.gz'."
-            )
+            # warnings.warn(
+            #    "Do not apply the file extensions. The filename should not end with 'json.gz'."
+            # )
             filename = filename[:-7]
         if filename.endswith("json"):
             filename = filename[:-4]
-            warnings.warn(
-                "Do not apply the file extensions. The filename should not end with 'json'."
-            )
+            # warnings.warn(
+            #    "Do not apply the file extensions. The filename should not end with 'json'."
+            # )
 
         if compress:
-            with gzip.open(filename + ".json.gz", "wb") as f:
+            full_file_name = filename + ".json.gz"
+            with gzip.open(full_file_name, "wb") as f:
                 f.write(json.dumps(self.to_dict()).encode("utf-8"))
         else:
+            full_file_name = filename + ".json"
             with open(filename + ".json", "w") as f:
                 f.write(json.dumps(self.to_dict()))
 
+        print("Saved to", full_file_name)
+
     @staticmethod
     def open_compressed_file(filename):
         with gzip.open(filename, "rb") as f:
@@ -160,11 +164,11 @@ class PersistenceMixin:
             d = cls.open_regular_file(filename)
         else:
             try:
-                d = cls.open_compressed_file(filename)
+                d = cls.open_compressed_file(filename + ".json.gz")
             except:
-                d = cls.open_regular_file(filename)
-            finally:
-                raise ValueError("File must be a json or json.gz file")
+                d = cls.open_regular_file(filename + ".json")
+            # finally:
+            #    raise ValueError("File must be a json or json.gz file")
 
         return cls.from_dict(d)
 

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.33.dev3"
+__version__ = "0.1.34"

edsl/agents/Invigilator.py

@@ -39,6 +39,8 @@ class InvigilatorAI(InvigilatorBase):
         }
         if "encoded_image" in prompts:
             params["encoded_image"] = prompts["encoded_image"]
+        if "files_list" in prompts:
+            params["files_list"] = prompts["files_list"]
 
         params.update({"iteration": self.iteration, "cache": self.cache})
 
@@ -80,15 +82,32 @@ class InvigilatorAI(InvigilatorBase):
         exception_occurred = None
         validated = False
         try:
-            validated_edsl_dict = self.question._validate_answer(edsl_dict)
+            # if the question has jinja parameters, it might be easier to make a new question
+            # with those all filled in & then validate that
+            # breakpoint()
+            if self.question.parameters:
+                prior_answers_dict = self.prompt_constructor.prior_answers_dict()
+                question_with_validators = self.question.render(
+                    self.scenario | prior_answers_dict
+                )
+                question_with_validators.use_code = self.question.use_code
+                # if question_with_validators.parameters:
+                #     raise ValueError(
+                #         f"The question still has parameters after rendering: {question_with_validators}"
+                #     )
+            else:
+                question_with_validators = self.question
+
+            # breakpoint()
+            validated_edsl_dict = question_with_validators._validate_answer(edsl_dict)
             answer = self.determine_answer(validated_edsl_dict["answer"])
             comment = validated_edsl_dict.get("comment", "")
             validated = True
         except QuestionAnswerValidationError as e:
             answer = None
             comment = "The response was not valid."
-            if self.raise_validation_errors:
-                exception_occurred = e
+            # if self.raise_validation_errors:
+            exception_occurred = e
         except Exception as non_validation_error:
             answer = None
             comment = "Some other error occurred."

edsl/agents/PromptConstructor.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from typing import Dict, Any, Optional, Set
 from collections import UserList
-import enum
+import pdb
 
 from jinja2 import Environment, meta
 
@@ -10,12 +10,7 @@ from edsl.data_transfer_models import ImageInfo
 from edsl.prompts.registry import get_classes as prompt_lookup
 from edsl.exceptions import QuestionScenarioRenderError
 
-
-class PromptComponent(enum.Enum):
-    AGENT_INSTRUCTIONS = "agent_instructions"
-    AGENT_PERSONA = "agent_persona"
-    QUESTION_INSTRUCTIONS = "question_instructions"
-    PRIOR_QUESTION_MEMORY = "prior_question_memory"
+from edsl.agents.prompt_helpers import PromptComponent, PromptList, PromptPlan
 
 
 def get_jinja2_variables(template_str: str) -> Set[str]:
@@ -33,127 +28,8 @@ def get_jinja2_variables(template_str: str) -> Set[str]:
     return meta.find_undeclared_variables(ast)
 
 
-class PromptList(UserList):
-    separator = Prompt(" ")
-
-    def reduce(self):
-        """Reduce the list of prompts to a single prompt.
-
-        >>> p = PromptList([Prompt("You are a happy-go lucky agent."), Prompt("You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}")])
-        >>> p.reduce()
-        Prompt(text=\"""You are a happy-go lucky agent. You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}\""")
-
-        """
-        p = self[0]
-        for prompt in self[1:]:
-            if len(prompt) > 0:
-                p = p + self.separator + prompt
-        return p
-
-
-class PromptPlan:
-    """A plan for constructing prompts for the LLM call.
-    Every prompt plan has a user prompt order and a system prompt order.
-    It must contain each of the values in the PromptComponent enum.
-
-
-    >>> p = PromptPlan(user_prompt_order=(PromptComponent.AGENT_INSTRUCTIONS, PromptComponent.AGENT_PERSONA),system_prompt_order=(PromptComponent.QUESTION_INSTRUCTIONS, PromptComponent.PRIOR_QUESTION_MEMORY))
-    >>> p._is_valid_plan()
-    True
-
-    >>> p.arrange_components(agent_instructions=1, agent_persona=2, question_instructions=3, prior_question_memory=4)
-    {'user_prompt': ..., 'system_prompt': ...}
-
-    >>> p = PromptPlan(user_prompt_order=("agent_instructions", ), system_prompt_order=("question_instructions", "prior_question_memory"))
-    Traceback (most recent call last):
-    ...
-    ValueError: Invalid plan: must contain each value of PromptComponent exactly once.
-
-    """
-
-    def __init__(
-        self,
-        user_prompt_order: Optional[tuple] = None,
-        system_prompt_order: Optional[tuple] = None,
-    ):
-        """Initialize the PromptPlan."""
-
-        if user_prompt_order is None:
-            user_prompt_order = (
-                PromptComponent.QUESTION_INSTRUCTIONS,
-                PromptComponent.PRIOR_QUESTION_MEMORY,
-            )
-        if system_prompt_order is None:
-            system_prompt_order = (
-                PromptComponent.AGENT_INSTRUCTIONS,
-                PromptComponent.AGENT_PERSONA,
-            )
-
-        # very commmon way to screw this up given how python treats single strings as iterables
-        if isinstance(user_prompt_order, str):
-            user_prompt_order = (user_prompt_order,)
-
-        if isinstance(system_prompt_order, str):
-            system_prompt_order = (system_prompt_order,)
-
-        if not isinstance(user_prompt_order, tuple):
-            raise TypeError(
-                f"Expected a tuple, but got {type(user_prompt_order).__name__}"
-            )
-
-        if not isinstance(system_prompt_order, tuple):
-            raise TypeError(
-                f"Expected a tuple, but got {type(system_prompt_order).__name__}"
-            )
-
-        self.user_prompt_order = self._convert_to_enum(user_prompt_order)
-        self.system_prompt_order = self._convert_to_enum(system_prompt_order)
-        if not self._is_valid_plan():
-            raise ValueError(
-                "Invalid plan: must contain each value of PromptComponent exactly once."
-            )
-
-    def _convert_to_enum(self, prompt_order: tuple):
-        """Convert string names to PromptComponent enum values."""
-        return tuple(
-            PromptComponent(component) if isinstance(component, str) else component
-            for component in prompt_order
-        )
-
-    def _is_valid_plan(self):
-        """Check if the plan is valid."""
-        combined = self.user_prompt_order + self.system_prompt_order
-        return set(combined) == set(PromptComponent)
-
-    def arrange_components(self, **kwargs) -> Dict[PromptComponent, Prompt]:
-        """Arrange the components in the order specified by the plan."""
-        # check is valid components passed
-        component_strings = set([pc.value for pc in PromptComponent])
-        if not set(kwargs.keys()) == component_strings:
-            raise ValueError(
-                f"Invalid components passed: {set(kwargs.keys())} but expected {PromptComponent}"
-            )
-
-        user_prompt = PromptList(
-            [kwargs[component.value] for component in self.user_prompt_order]
-        )
-        system_prompt = PromptList(
-            [kwargs[component.value] for component in self.system_prompt_order]
-        )
-        return {"user_prompt": user_prompt, "system_prompt": system_prompt}
-
-    def get_prompts(self, **kwargs) -> Dict[str, Prompt]:
-        """Get both prompts for the LLM call."""
-        prompts = self.arrange_components(**kwargs)
-        return {
-            "user_prompt": prompts["user_prompt"].reduce(),
-            "system_prompt": prompts["system_prompt"].reduce(),
-        }
-
-
 class PromptConstructor:
-    """Mixin for constructing prompts for the LLM call.
-
+    """
     The pieces of a prompt are:
     - The agent instructions - "You are answering questions as if you were a human. Do not break character."
     - The persona prompt - "You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}"
@@ -172,18 +48,20 @@ class PromptConstructor:
         self.model = invigilator.model
         self.current_answers = invigilator.current_answers
         self.memory_plan = invigilator.memory_plan
-        self.prompt_plan = PromptPlan()  # Assuming PromptPlan is defined elsewhere
-
-        # prompt_plan = PromptPlan()
+        self.prompt_plan = PromptPlan()
 
     @property
-    def scenario_image_keys(self):
-        image_entries = []
+    def scenario_file_keys(self) -> list:
+        """We need to find all the keys in the scenario that refer to FileStore objects.
+        These will be used to append to the prompt a list of files that are part of the scenario.
+        """
+        from edsl.scenarios.FileStore import FileStore
 
+        file_entries = []
         for key, value in self.scenario.items():
-            if isinstance(value, ImageInfo):
-                image_entries.append(key)
-        return image_entries
+            if isinstance(value, FileStore):
+                file_entries.append(key)
+        return file_entries
 
     @property
     def agent_instructions_prompt(self) -> Prompt:
@@ -219,47 +97,51 @@ class PromptConstructor:
         {'age': 22, 'hair': 'brown', 'height': 5.5}\""")
 
         """
-        if not hasattr(self, "_agent_persona_prompt"):
-            from edsl import Agent
+        from edsl import Agent
 
-            if self.agent == Agent():  # if agent is empty, then return an empty prompt
-                return Prompt(text="")
+        if hasattr(self, "_agent_persona_prompt"):
+            return self._agent_persona_prompt
 
-            if not hasattr(self.agent, "agent_persona"):
-                applicable_prompts = prompt_lookup(
-                    component_type="agent_persona",
-                    model=self.model.model,
-                )
-                persona_prompt_template = applicable_prompts[0]()
-            else:
-                persona_prompt_template = self.agent.agent_persona
-
-            # TODO: This multiple passing of agent traits - not sure if it is necessary. Not harmful.
-            if undefined := persona_prompt_template.undefined_template_variables(
-                self.agent.traits
-                | {"traits": self.agent.traits}
-                | {"codebook": self.agent.codebook}
-                | {"traits": self.agent.traits}
-            ):
-                raise QuestionScenarioRenderError(
-                    f"Agent persona still has variables that were not rendered: {undefined}"
-                )
+        if self.agent == Agent():  # if agent is empty, then return an empty prompt
+            return Prompt(text="")
 
-            persona_prompt = persona_prompt_template.render(
-                self.agent.traits | {"traits": self.agent.traits},
-                codebook=self.agent.codebook,
-                traits=self.agent.traits,
+        if not hasattr(self.agent, "agent_persona"):
+            applicable_prompts = prompt_lookup(
+                component_type="agent_persona",
+                model=self.model.model,
             )
-            if persona_prompt.has_variables:
-                raise QuestionScenarioRenderError(
-                    "Agent persona still has variables that were not rendered."
-                )
-            self._agent_persona_prompt = persona_prompt
+            persona_prompt_template = applicable_prompts[0]()
+        else:
+            persona_prompt_template = self.agent.agent_persona
+
+        # TODO: This multiple passing of agent traits - not sure if it is necessary. Not harmful.
+        template_parameter_dictionary = (
+            self.agent.traits
+            | {"traits": self.agent.traits}
+            | {"codebook": self.agent.codebook}
+            | {"traits": self.agent.traits}
+        )
+
+        if undefined := persona_prompt_template.undefined_template_variables(
+            template_parameter_dictionary
+        ):
+            raise QuestionScenarioRenderError(
+                f"Agent persona still has variables that were not rendered: {undefined}"
+            )
+
+        persona_prompt = persona_prompt_template.render(template_parameter_dictionary)
+        if persona_prompt.has_variables:
+            raise QuestionScenarioRenderError(
+                "Agent persona still has variables that were not rendered."
+            )
+
+        self._agent_persona_prompt = persona_prompt
 
         return self._agent_persona_prompt
 
     def prior_answers_dict(self) -> dict:
         d = self.survey.question_names_to_questions()
+        # This attaches the answer to the question
         for question, answer in self.current_answers.items():
             if question in d:
                 d[question].answer = answer
@@ -270,14 +152,14 @@ class PromptConstructor:
         return d
 
     @property
-    def question_image_keys(self):
+    def question_file_keys(self):
         raw_question_text = self.question.question_text
         variables = get_jinja2_variables(raw_question_text)
-        question_image_keys = []
+        question_file_keys = []
         for var in variables:
-            if var in self.scenario_image_keys:
-                question_image_keys.append(var)
-        return question_image_keys
+            if var in self.scenario_file_keys:
+                question_file_keys.append(var)
+        return question_file_keys
 
     @property
     def question_instructions_prompt(self) -> Prompt:
@@ -288,15 +170,17 @@ class PromptConstructor:
         Prompt(text=\"""...
         ...
         """
+        # The user might have passed a custom prompt, which would be stored in _question_instructions_prompt
         if not hasattr(self, "_question_instructions_prompt"):
+            # Gets the instructions for the question - this is how the question should be answered
             question_prompt = self.question.get_instructions(model=self.model.model)
 
-            # Are any of the scenario values ImageInfo
-
+            # Get the data for the question - this is a dictionary of the question data
+            # e.g., {'question_text': 'Do you like school?', 'question_name': 'q0', 'question_options': ['yes', 'no']}
             question_data = self.question.data.copy()
 
             # check to see if the question_options is actually a string
-            # This is used when the user is using the question_options as a variable from a sceario
+            # This is used when the user is using the question_options as a variable from a scenario
             # if "question_options" in question_data:
             if isinstance(self.question.data.get("question_options", None), str):
                 env = Environment()
@@ -305,19 +189,31 @@ class PromptConstructor:
                     meta.find_undeclared_variables(parsed_content)
                 )[0]
 
+                # look to see if the question_option_key is in the scenario
                 if isinstance(
                     question_options := self.scenario.get(question_option_key), list
                 ):
                     question_data["question_options"] = question_options
                     self.question.question_options = question_options
 
+                # might be getting it from the prior answers
+                if self.prior_answers_dict().get(question_option_key) is not None:
+                    if isinstance(
+                        question_options := self.prior_answers_dict()
+                        .get(question_option_key)
+                        .answer,
+                        list,
+                    ):
+                        question_data["question_options"] = question_options
+                        self.question.question_options = question_options
+
             replacement_dict = (
-                {key: "<see image>" for key in self.scenario_image_keys}
+                {key: f"<see file {key}>" for key in self.scenario_file_keys}
                 | question_data
                 | {
                     k: v
                     for k, v in self.scenario.items()
-                    if k not in self.scenario_image_keys
+                    if k not in self.scenario_file_keys
                 }  # don't include images in the replacement dict
                 | self.prior_answers_dict()
                 | {"agent": self.agent}
@@ -345,6 +241,7 @@ class PromptConstructor:
                     )
 
             if undefined_template_variables:
+                # breakpoint()
                 raise QuestionScenarioRenderError(
                     f"Question instructions still has variables: {undefined_template_variables}."
                 )
@@ -425,19 +322,18 @@ class PromptConstructor:
         >>> i.get_prompts()
         {'user_prompt': ..., 'system_prompt': ...}
         """
+        # breakpoint()
         prompts = self.prompt_plan.get_prompts(
             agent_instructions=self.agent_instructions_prompt,
             agent_persona=self.agent_persona_prompt,
             question_instructions=self.question_instructions_prompt,
             prior_question_memory=self.prior_question_memory_prompt,
         )
-        if len(self.question_image_keys) > 1:
-            raise ValueError("We can only handle one image per question.")
-        elif len(self.question_image_keys) == 1:
-            prompts["encoded_image"] = self.scenario[
-                self.question_image_keys[0]
-            ].encoded_image
-
+        if self.question_file_keys:
+            files_list = []
+            for key in self.question_file_keys:
+                files_list.append(self.scenario[key])
+            prompts["files_list"] = files_list
         return prompts
 
     def _get_scenario_with_image(self) -> Scenario:

edsl/agents/prompt_helpers.py

@@ -0,0 +1,129 @@
+import enum
+from typing import Dict, Optional
+from collections import UserList
+from edsl.prompts import Prompt
+
+
+class PromptComponent(enum.Enum):
+    AGENT_INSTRUCTIONS = "agent_instructions"
+    AGENT_PERSONA = "agent_persona"
+    QUESTION_INSTRUCTIONS = "question_instructions"
+    PRIOR_QUESTION_MEMORY = "prior_question_memory"
+
+
+class PromptList(UserList):
+    separator = Prompt(" ")
+
+    def reduce(self):
+        """Reduce the list of prompts to a single prompt.
+
+        >>> p = PromptList([Prompt("You are a happy-go lucky agent."), Prompt("You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}")])
+        >>> p.reduce()
+        Prompt(text=\"""You are a happy-go lucky agent. You are an agent with the following persona: {'age': 22, 'hair': 'brown', 'height': 5.5}\""")
+
+        """
+        p = self[0]
+        for prompt in self[1:]:
+            if len(prompt) > 0:
+                p = p + self.separator + prompt
+        return p
+
+
+class PromptPlan:
+    """A plan for constructing prompts for the LLM call.
+    Every prompt plan has a user prompt order and a system prompt order.
+    It must contain each of the values in the PromptComponent enum.
+
+
+    >>> p = PromptPlan(user_prompt_order=(PromptComponent.AGENT_INSTRUCTIONS, PromptComponent.AGENT_PERSONA),system_prompt_order=(PromptComponent.QUESTION_INSTRUCTIONS, PromptComponent.PRIOR_QUESTION_MEMORY))
+    >>> p._is_valid_plan()
+    True
+
+    >>> p.arrange_components(agent_instructions=1, agent_persona=2, question_instructions=3, prior_question_memory=4)
+    {'user_prompt': ..., 'system_prompt': ...}
+
+    >>> p = PromptPlan(user_prompt_order=("agent_instructions", ), system_prompt_order=("question_instructions", "prior_question_memory"))
+    Traceback (most recent call last):
+    ...
+    ValueError: Invalid plan: must contain each value of PromptComponent exactly once.
+
+    """
+
+    def __init__(
+        self,
+        user_prompt_order: Optional[tuple] = None,
+        system_prompt_order: Optional[tuple] = None,
+    ):
+        """Initialize the PromptPlan."""
+
+        if user_prompt_order is None:
+            user_prompt_order = (
+                PromptComponent.QUESTION_INSTRUCTIONS,
+                PromptComponent.PRIOR_QUESTION_MEMORY,
+            )
+        if system_prompt_order is None:
+            system_prompt_order = (
+                PromptComponent.AGENT_INSTRUCTIONS,
+                PromptComponent.AGENT_PERSONA,
+            )
+
+        # very commmon way to screw this up given how python treats single strings as iterables
+        if isinstance(user_prompt_order, str):
+            user_prompt_order = (user_prompt_order,)
+
+        if isinstance(system_prompt_order, str):
+            system_prompt_order = (system_prompt_order,)
+
+        if not isinstance(user_prompt_order, tuple):
+            raise TypeError(
+                f"Expected a tuple, but got {type(user_prompt_order).__name__}"
+            )
+
+        if not isinstance(system_prompt_order, tuple):
+            raise TypeError(
+                f"Expected a tuple, but got {type(system_prompt_order).__name__}"
+            )
+
+        self.user_prompt_order = self._convert_to_enum(user_prompt_order)
+        self.system_prompt_order = self._convert_to_enum(system_prompt_order)
+        if not self._is_valid_plan():
+            raise ValueError(
+                "Invalid plan: must contain each value of PromptComponent exactly once."
+            )
+
+    def _convert_to_enum(self, prompt_order: tuple):
+        """Convert string names to PromptComponent enum values."""
+        return tuple(
+            PromptComponent(component) if isinstance(component, str) else component
+            for component in prompt_order
+        )
+
+    def _is_valid_plan(self):
+        """Check if the plan is valid."""
+        combined = self.user_prompt_order + self.system_prompt_order
+        return set(combined) == set(PromptComponent)
+
+    def arrange_components(self, **kwargs) -> Dict[PromptComponent, Prompt]:
+        """Arrange the components in the order specified by the plan."""
+        # check is valid components passed
+        component_strings = set([pc.value for pc in PromptComponent])
+        if not set(kwargs.keys()) == component_strings:
+            raise ValueError(
+                f"Invalid components passed: {set(kwargs.keys())} but expected {PromptComponent}"
+            )
+
+        user_prompt = PromptList(
+            [kwargs[component.value] for component in self.user_prompt_order]
+        )
+        system_prompt = PromptList(
+            [kwargs[component.value] for component in self.system_prompt_order]
+        )
+        return {"user_prompt": user_prompt, "system_prompt": system_prompt}
+
+    def get_prompts(self, **kwargs) -> Dict[str, Prompt]:
+        """Get both prompts for the LLM call."""
+        prompts = self.arrange_components(**kwargs)
+        return {
+            "user_prompt": prompts["user_prompt"].reduce(),
+            "system_prompt": prompts["system_prompt"].reduce(),
+        }

edsl/coop/coop.py

@@ -803,8 +803,9 @@ def main():
     ##############
     job = Jobs.example()
     coop.remote_inference_cost(job)
-    results = coop.remote_inference_create(job)
-    coop.remote_inference_get(results.get("uuid"))
+    job_coop_object = coop.remote_inference_create(job)
+    job_coop_results = coop.remote_inference_get(job_coop_object.get("uuid"))
+    coop.get(uuid=job_coop_results.get("results_uuid"))
 
     ##############
     # E. Errors

edsl/data_transfer_models.py

@@ -3,7 +3,6 @@ from dataclasses import dataclass, fields
 import reprlib
 
 
-
 class ModelInputs(NamedTuple):
     "This is what was send by the agent to the model"
     user_prompt: str

edsl/inference_services/AnthropicService.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any
+from typing import Any, Optional, List
 import re
 from anthropic import AsyncAnthropic
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
@@ -60,7 +60,10 @@ class AnthropicService(InferenceServiceABC):
             _rpm = cls.get_rpm(cls)
 
             async def async_execute_model_call(
-                self, user_prompt: str, system_prompt: str = ""
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["Files"]] = None,
             ) -> dict[str, Any]:
                 """Calls the OpenAI API and returns the API response."""
 

edsl/inference_services/AwsBedrock.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any
+from typing import Any, List, Optional
 import re
 import boto3
 from botocore.exceptions import ClientError
@@ -69,7 +69,10 @@ class AwsBedrockService(InferenceServiceABC):
             _tpm = cls.get_tpm(cls)
 
             async def async_execute_model_call(
-                self, user_prompt: str, system_prompt: str = ""
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["FileStore"]] = None,
             ) -> dict[str, Any]:
                 """Calls the AWS Bedrock API and returns the API response."""