edsl 0.1.33.dev2__py3-none-any.whl → 0.1.33.dev3__py3-none-any.whl

edsl/Base.py

@@ -47,21 +47,27 @@ class PersistenceMixin:
         self,
         description: Optional[str] = None,
         visibility: Optional[str] = "unlisted",
+        expected_parrot_url: Optional[str] = None,
     ):
         """Post the object to coop."""
         from edsl.coop import Coop
 
-        c = Coop()
+        c = Coop(url=expected_parrot_url)
         return c.create(self, description, visibility)
 
     @classmethod
-    def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
+    def pull(
+        cls,
+        uuid: Optional[Union[str, UUID]] = None,
+        url: Optional[str] = None,
+        expected_parrot_url: Optional[str] = None,
+    ):
         """Pull the object from coop."""
         from edsl.coop import Coop
         from edsl.coop.utils import ObjectRegistry
 
         object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
-        coop = Coop()
+        coop = Coop(url=expected_parrot_url)
         return coop.get(uuid, url, object_type)
 
     @classmethod

edsl/__init__.py

@@ -23,6 +23,7 @@ from edsl.questions import QuestionNumerical
 from edsl.questions import QuestionYesNo
 from edsl.questions import QuestionBudget
 from edsl.questions import QuestionRank
+from edsl.questions import QuestionTopK
 
 from edsl.scenarios import Scenario
 from edsl.scenarios import ScenarioList

edsl/__version__.py

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

edsl/agents/Agent.py

@@ -586,9 +586,9 @@ class Agent(Base):
             if dynamic_traits_func:
                 func = inspect.getsource(dynamic_traits_func)
                 raw_data["dynamic_traits_function_source_code"] = func
-                raw_data["dynamic_traits_function_name"] = (
-                    self.dynamic_traits_function_name
-                )
+                raw_data[
+                    "dynamic_traits_function_name"
+                ] = self.dynamic_traits_function_name
         if hasattr(self, "answer_question_directly"):
             raw_data.pop(
                 "answer_question_directly", None
@@ -604,9 +604,9 @@ class Agent(Base):
                 raw_data["answer_question_directly_source_code"] = inspect.getsource(
                     answer_question_directly_func
                 )
-                raw_data["answer_question_directly_function_name"] = (
-                    self.answer_question_directly_function_name
-                )
+                raw_data[
+                    "answer_question_directly_function_name"
+                ] = self.answer_question_directly_function_name
 
         return raw_data
 

edsl/agents/Invigilator.py

@@ -2,14 +2,13 @@
 
 from typing import Dict, Any, Optional
 
-from edsl.exceptions import AgentRespondedWithBadJSONError
 from edsl.prompts.Prompt import Prompt
 from edsl.utilities.decorators import sync_wrapper, jupyter_nb_handler
 from edsl.prompts.registry import get_classes as prompt_lookup
 from edsl.exceptions.questions import QuestionAnswerValidationError
-from edsl.agents.PromptConstructionMixin import PromptConstructorMixin
 from edsl.agents.InvigilatorBase import InvigilatorBase
 from edsl.data_transfer_models import AgentResponseDict, EDSLResultObjectInput
+from edsl.agents.PromptConstructor import PromptConstructor
 
 
 class NotApplicable(str):
@@ -19,9 +18,13 @@ class NotApplicable(str):
         return instance
 
 
-class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
+class InvigilatorAI(InvigilatorBase):
     """An invigilator that uses an AI model to answer questions."""
 
+    def get_prompts(self) -> Dict[str, Prompt]:
+        """Return the prompts used."""
+        return self.prompt_constructor.get_prompts()
+
     async def async_answer_question(self) -> AgentResponseDict:
         """Answer a question using the AI model.
 

edsl/agents/InvigilatorBase.py

@@ -14,6 +14,7 @@ from edsl.surveys.MemoryPlan import MemoryPlan
 from edsl.language_models.LanguageModel import LanguageModel
 
 from edsl.data_transfer_models import EDSLResultObjectInput
+from edsl.agents.PromptConstructor import PromptConstructor
 
 
 class InvigilatorBase(ABC):
@@ -27,16 +28,7 @@ class InvigilatorBase(ABC):
 
     This returns an empty prompt because there is no memory the agent needs to have at q0.
 
-    >>> InvigilatorBase.example().create_memory_prompt("q0")
-    Prompt(text=\"""\""")
 
-    >>> i = InvigilatorBase.example()
-    >>> i.current_answers = {"q0": "Prior answer"}
-    >>> i.memory_plan.add_single_memory("q1", "q0")
-    >>> i.create_memory_prompt("q1")
-    Prompt(text=\"""
-            Before the question you are now answering, you already answered the following question(s):
-    ...
     """
 
     def __init__(
@@ -72,6 +64,11 @@ class InvigilatorBase(ABC):
             None  # placeholder for the raw response from the model
         )
 
+    @property
+    def prompt_constructor(self) -> PromptConstructor:
+        """Return the prompt constructor."""
+        return PromptConstructor(self)
+
     def to_dict(self):
         attributes = [
             "agent",
@@ -207,22 +204,6 @@ class InvigilatorBase(ABC):
 
         return main()
 
-    def create_memory_prompt(self, question_name: str) -> Prompt:
-        """Create a memory for the agent.
-
-        The returns a memory prompt for the agent.
-
-        >>> i = InvigilatorBase.example()
-        >>> i.current_answers = {"q0": "Prior answer"}
-        >>> i.memory_plan.add_single_memory("q1", "q0")
-        >>> p = i.create_memory_prompt("q1")
-        >>> p.text.strip().replace("\\n", " ").replace("\\t", " ")
-        'Before the question you are now answering, you already answered the following question(s):          Question: Do you like school?  Answer: Prior answer'
-        """
-        return self.memory_plan.get_memory_prompt_fragment(
-            question_name, self.current_answers
-        )
-
     @classmethod
     def example(
         cls, throw_an_exception=False, question=None, scenario=None, survey=None
@@ -285,9 +266,9 @@ class InvigilatorBase(ABC):
 
         memory_plan = MemoryPlan(survey=survey)
         current_answers = None
-        from edsl.agents.PromptConstructionMixin import PromptConstructorMixin
+        from edsl.agents.PromptConstructor import PromptConstructor
 
-        class InvigilatorExample(PromptConstructorMixin, InvigilatorBase):
+        class InvigilatorExample(InvigilatorBase):
             """An example invigilator."""
 
             async def async_answer_question(self):

edsl/agents/{PromptConstructionMixin.py → PromptConstructor.py}

@@ -1,16 +1,15 @@
 from __future__ import annotations
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, Set
 from collections import UserList
+import enum
 
-# from functools import reduce
-from edsl.prompts.Prompt import Prompt
+from jinja2 import Environment, meta
 
-# from edsl.utilities.decorators import sync_wrapper, jupyter_nb_handler
+from edsl.prompts.Prompt import Prompt
+from edsl.data_transfer_models import ImageInfo
 from edsl.prompts.registry import get_classes as prompt_lookup
 from edsl.exceptions import QuestionScenarioRenderError
 
-import enum
-
 
 class PromptComponent(enum.Enum):
     AGENT_INSTRUCTIONS = "agent_instructions"
@@ -19,6 +18,21 @@ class PromptComponent(enum.Enum):
     PRIOR_QUESTION_MEMORY = "prior_question_memory"
 
 
+def get_jinja2_variables(template_str: str) -> Set[str]:
+    """
+    Extracts all variable names from a Jinja2 template using Jinja2's built-in parsing.
+
+    Args:
+    template_str (str): The Jinja2 template string
+
+    Returns:
+    Set[str]: A set of variable names found in the template
+    """
+    env = Environment()
+    ast = env.parse(template_str)
+    return meta.find_undeclared_variables(ast)
+
+
 class PromptList(UserList):
     separator = Prompt(" ")
 
@@ -137,7 +151,7 @@ class PromptPlan:
         }
 
 
-class PromptConstructorMixin:
+class PromptConstructor:
     """Mixin for constructing prompts for the LLM call.
 
     The pieces of a prompt are:
@@ -149,16 +163,40 @@ class PromptConstructorMixin:
     This is mixed into the Invigilator class.
     """
 
-    prompt_plan = PromptPlan()
+    def __init__(self, invigilator):
+        self.invigilator = invigilator
+        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
+        self.prompt_plan = PromptPlan()  # Assuming PromptPlan is defined elsewhere
+
+        # prompt_plan = PromptPlan()
+
+    @property
+    def scenario_image_keys(self):
+        image_entries = []
+
+        for key, value in self.scenario.items():
+            if isinstance(value, ImageInfo):
+                image_entries.append(key)
+        return image_entries
 
     @property
     def agent_instructions_prompt(self) -> Prompt:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
         >>> i = InvigilatorBase.example()
-        >>> i.agent_instructions_prompt
+        >>> i.prompt_constructor.agent_instructions_prompt
         Prompt(text=\"""You are answering questions as if you were a human. Do not break character.\""")
         """
+        from edsl import Agent
+
+        if self.agent == Agent():  # if agent is empty, then return an empty prompt
+            return Prompt(text="")
         if not hasattr(self, "_agent_instructions_prompt"):
             applicable_prompts = prompt_lookup(
                 component_type="agent_instructions",
@@ -176,12 +214,17 @@ class PromptConstructorMixin:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
         >>> i = InvigilatorBase.example()
-        >>> i.agent_persona_prompt
+        >>> i.prompt_constructor.agent_persona_prompt
         Prompt(text=\"""You are an agent with the following persona:
         {'age': 22, 'hair': 'brown', 'height': 5.5}\""")
 
         """
         if not hasattr(self, "_agent_persona_prompt"):
+            from edsl import Agent
+
+            if self.agent == Agent():  # if agent is empty, then return an empty prompt
+                return Prompt(text="")
+
             if not hasattr(self.agent, "agent_persona"):
                 applicable_prompts = prompt_lookup(
                     component_type="agent_persona",
@@ -226,27 +269,29 @@ class PromptConstructorMixin:
                     d[new_question].comment = answer
         return d
 
+    @property
+    def question_image_keys(self):
+        raw_question_text = self.question.question_text
+        variables = get_jinja2_variables(raw_question_text)
+        question_image_keys = []
+        for var in variables:
+            if var in self.scenario_image_keys:
+                question_image_keys.append(var)
+        return question_image_keys
+
     @property
     def question_instructions_prompt(self) -> Prompt:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
         >>> i = InvigilatorBase.example()
-        >>> i.question_instructions_prompt
+        >>> i.prompt_constructor.question_instructions_prompt
         Prompt(text=\"""...
         ...
         """
         if not hasattr(self, "_question_instructions_prompt"):
             question_prompt = self.question.get_instructions(model=self.model.model)
 
-            # TODO: Try to populate the answers in the question object if they are available
-            # d = self.survey.question_names_to_questions()
-            # for question, answer in self.current_answers.items():
-            #     if question in d:
-            #         d[question].answer = answer
-            #     else:
-            #         # adds a comment to the question
-            #         if (new_question := question.split("_comment")[0]) in d:
-            #             d[new_question].comment = answer
+            # Are any of the scenario values ImageInfo
 
             question_data = self.question.data.copy()
 
@@ -254,8 +299,6 @@ class PromptConstructorMixin:
             # This is used when the user is using the question_options as a variable from a sceario
             # if "question_options" in question_data:
             if isinstance(self.question.data.get("question_options", None), str):
-                from jinja2 import Environment, meta
-
                 env = Environment()
                 parsed_content = env.parse(self.question.data["question_options"])
                 question_option_key = list(
@@ -269,8 +312,13 @@ class PromptConstructorMixin:
                     self.question.question_options = question_options
 
             replacement_dict = (
-                question_data
-                | self.scenario
+                {key: "<see image>" for key in self.scenario_image_keys}
+                | question_data
+                | {
+                    k: v
+                    for k, v in self.scenario.items()
+                    if k not in self.scenario_image_keys
+                }  # don't include images in the replacement dict
                 | self.prior_answers_dict()
                 | {"agent": self.agent}
                 | {
@@ -280,9 +328,10 @@ class PromptConstructorMixin:
                     ),
                 }
             )
-            # breakpoint()
+
             rendered_instructions = question_prompt.render(replacement_dict)
-            # breakpoint()
+
+            # is there anything left to render?
             undefined_template_variables = (
                 rendered_instructions.undefined_template_variables({})
             )
@@ -300,7 +349,9 @@ class PromptConstructorMixin:
                     f"Question instructions still has variables: {undefined_template_variables}."
                 )
 
-            # Check if question has an instructions
+            ####################################
+            # Check if question has instructions - these are instructions in a Survey that can apply to multiple follow-on questions
+            ####################################
             relevant_instructions = self.survey.relevant_instructions(
                 self.question.question_name
             )
@@ -329,6 +380,23 @@ class PromptConstructorMixin:
             self._prior_question_memory_prompt = memory_prompt
         return self._prior_question_memory_prompt
 
+    def create_memory_prompt(self, question_name: str) -> Prompt:
+        """Create a memory for the agent.
+
+        The returns a memory prompt for the agent.
+
+        >>> from edsl.agents.InvigilatorBase import InvigilatorBase
+        >>> i = InvigilatorBase.example()
+        >>> i.current_answers = {"q0": "Prior answer"}
+        >>> i.memory_plan.add_single_memory("q1", "q0")
+        >>> p = i.prompt_constructor.create_memory_prompt("q1")
+        >>> p.text.strip().replace("\\n", " ").replace("\\t", " ")
+        'Before the question you are now answering, you already answered the following question(s):          Question: Do you like school?  Answer: Prior answer'
+        """
+        return self.memory_plan.get_memory_prompt_fragment(
+            question_name, self.current_answers
+        )
+
     def construct_system_prompt(self) -> Prompt:
         """Construct the system prompt for the LLM call."""
         import warnings
@@ -363,9 +431,13 @@ class PromptConstructorMixin:
             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 hasattr(self.scenario, "has_image") and self.scenario.has_image:
-            prompts["encoded_image"] = self.scenario["encoded_image"]
         return prompts
 
     def _get_scenario_with_image(self) -> Scenario:

edsl/config.py

@@ -1,73 +1,65 @@
 """This module provides a Config class that loads environment variables from a .env file and sets them as class attributes."""
 
 import os
+from dotenv import load_dotenv, find_dotenv
 from edsl.exceptions import (
     InvalidEnvironmentVariableError,
     MissingEnvironmentVariableError,
 )
-from dotenv import load_dotenv, find_dotenv
 
 # valid values for EDSL_RUN_MODE
-EDSL_RUN_MODES = ["development", "development-testrun", "production"]
+EDSL_RUN_MODES = [
+    "development",
+    "development-testrun",
+    "production",
+]
 
 # `default` is used to impute values only in "production" mode
 # `info` gives a brief description of the env var
 CONFIG_MAP = {
     "EDSL_RUN_MODE": {
         "default": "production",
-        "info": "This env var determines the run mode of the application.",
-    },
-    "EDSL_DATABASE_PATH": {
-        "default": f"sqlite:///{os.path.join(os.getcwd(), '.edsl_cache/data.db')}",
-        "info": "This env var determines the path to the cache file.",
-    },
-    "EDSL_LOGGING_PATH": {
-        "default": f"{os.path.join(os.getcwd(), 'interview.log')}",
-        "info": "This env var determines the path to the log file.",
+        "info": "This config var determines the run mode of the application.",
     },
     "EDSL_API_TIMEOUT": {
         "default": "60",
-        "info": "This env var determines the maximum number of seconds to wait for an API call to return.",
+        "info": "This config var determines the maximum number of seconds to wait for an API call to return.",
     },
     "EDSL_BACKOFF_START_SEC": {
         "default": "1",
-        "info": "This env var determines the number of seconds to wait before retrying a failed API call.",
+        "info": "This config var determines the number of seconds to wait before retrying a failed API call.",
     },
-    "EDSL_MAX_BACKOFF_SEC": {
+    "EDSL_BACKOFF_MAX_SEC": {
         "default": "60",
-        "info": "This env var determines the maximum number of seconds to wait before retrying a failed API call.",
+        "info": "This config var determines the maximum number of seconds to wait before retrying a failed API call.",
     },
-    "EDSL_MAX_ATTEMPTS": {
-        "default": "5",
-        "info": "This env var determines the maximum number of times to retry a failed API call.",
+    "EDSL_DATABASE_PATH": {
+        "default": f"sqlite:///{os.path.join(os.getcwd(), '.edsl_cache/data.db')}",
+        "info": "This config var determines the path to the cache file.",
     },
     "EDSL_DEFAULT_MODEL": {
         "default": "gpt-4o",
-        "info": "This env var holds the default model name.",
+        "info": "This config var holds the default model that will be used if a model is not explicitly passed.",
     },
-    "EDSL_SERVICE_TPM_BASELINE": {
-        "default": "2000000",
-        "info": "This env var holds the maximum number of tokens per minute for all models. Model-specific values such as EDSL_SERVICE_TPM_OPENAI will override this.",
+    "EDSL_FETCH_TOKEN_PRICES": {
+        "default": "True",
+        "info": "This config var determines whether to fetch prices for tokens used in remote inference",
+    },
+    "EDSL_MAX_ATTEMPTS": {
+        "default": "5",
+        "info": "This config var determines the maximum number of times to retry a failed API call.",
     },
     "EDSL_SERVICE_RPM_BASELINE": {
         "default": "100",
-        "info": "This env var holds the maximum number of requests per minute for OpenAI. Model-specific values such as EDSL_SERVICE_RPM_OPENAI will override this.",
+        "info": "This config var holds the maximum number of requests per minute. Model-specific values provided in env vars such as EDSL_SERVICE_RPM_OPENAI will override this. value for the corresponding model",
     },
-    "EDSL_SERVICE_TPM_OPENAI": {
+    "EDSL_SERVICE_TPM_BASELINE": {
         "default": "2000000",
-        "info": "This env var holds the maximum number of tokens per minute for OpenAI.",
-    },
-    "EDSL_SERVICE_RPM_OPENAI": {
-        "default": "100",
-        "info": "This env var holds the maximum number of requests per minute for OpenAI.",
-    },
-    "EDSL_FETCH_TOKEN_PRICES": {
-        "default": "True",
-        "info": "Whether to fetch the prices for tokens",
+        "info": "This config var holds the maximum number of tokens per minute for all models. Model-specific values provided in env vars such as EDSL_SERVICE_TPM_OPENAI will override this value for the corresponding model.",
     },
     "EXPECTED_PARROT_URL": {
         "default": "https://www.expectedparrot.com",
-        "info": "This env var holds the URL of the Expected Parrot API.",
+        "info": "This config var holds the URL of the Expected Parrot API.",
     },
 }
 

edsl/coop/coop.py

@@ -59,8 +59,16 @@ class Coop:
         Send a request to the server and return the response.
         """
         url = f"{self.url}/{uri}"
+        method = method.upper()
+        if payload is None:
+            timeout = 20
+        elif (
+            method.upper() == "POST"
+            and "json_string" in payload
+            and payload.get("json_string") is not None
+        ):
+            timeout = max(20, (len(payload.get("json_string", "")) // (1024 * 1024)))
         try:
-            method = method.upper()
             if method in ["GET", "DELETE"]:
                 response = requests.request(
                     method, url, params=params, headers=self.headers, timeout=timeout
@@ -77,7 +85,7 @@ class Coop:
             else:
                 raise Exception(f"Invalid {method=}.")
         except requests.ConnectionError:
-            raise requests.ConnectionError("Could not connect to the server.")
+            raise requests.ConnectionError(f"Could not connect to the server at {url}.")
 
         return response
 
@@ -87,6 +95,7 @@ class Coop:
         """
         if response.status_code >= 400:
             message = response.json().get("detail")
+            # print(response.text)
             if "Authorization" in message:
                 print(message)
                 message = "Please provide an Expected Parrot API key."

edsl/data_transfer_models.py

@@ -1,4 +1,7 @@
 from typing import NamedTuple, Dict, List, Optional, Any
+from dataclasses import dataclass, fields
+import reprlib
+
 
 
 class ModelInputs(NamedTuple):
@@ -45,76 +48,27 @@ class EDSLResultObjectInput(NamedTuple):
     cost: Optional[float] = None
 
 
-# from collections import UserDict
-
-
-# class AgentResponseDict(UserDict):
-#     """A dictionary to store the response of the agent to a question."""
-
-#     def __init__(
-#         self,
-#         *,
-#         question_name,
-#         answer,
-#         prompts,
-#         generated_tokens: str,
-#         usage=None,
-#         comment=None,
-#         cached_response=None,
-#         raw_model_response=None,
-#         simple_model_raw_response=None,
-#         cache_used=None,
-#         cache_key=None,
-#     ):
-#         """Initialize the AgentResponseDict object."""
-#         usage = usage or {"prompt_tokens": 0, "completion_tokens": 0}
-#         if generated_tokens is None:
-#             raise ValueError("generated_tokens must be provided")
-#         self.data = {
-#             "answer": answer,
-#             "comment": comment,
-#             "question_name": question_name,
-#             "prompts": prompts,
-#             "usage": usage,
-#             "cached_response": cached_response,
-#             "raw_model_response": raw_model_response,
-#             "simple_model_raw_response": simple_model_raw_response,
-#             "cache_used": cache_used,
-#             "cache_key": cache_key,
-#             "generated_tokens": generated_tokens,
-#         }
-
-#     @property
-#     def data(self):
-#         return self._data
-
-#     @data.setter
-#     def data(self, value):
-#         self._data = value
-
-#     def __getitem__(self, key):
-#         return self.data.get(key, None)
-
-#     def __setitem__(self, key, value):
-#         self.data[key] = value
-
-#     def __delitem__(self, key):
-#         del self.data[key]
-
-#     def __iter__(self):
-#         return iter(self.data)
-
-#     def __len__(self):
-#         return len(self.data)
-
-#     def keys(self):
-#         return self.data.keys()
-
-#     def values(self):
-#         return self.data.values()
-
-#     def items(self):
-#         return self.data.items()
-
-#     def is_this_same_model(self):
-#         return True
+@dataclass
+class ImageInfo:
+    file_path: str
+    file_name: str
+    image_format: str
+    file_size: int
+    encoded_image: str
+
+    def __repr__(self):
+        reprlib_instance = reprlib.Repr()
+        reprlib_instance.maxstring = 30  # Limit the string length for the encoded image
+
+        # Get all fields except encoded_image
+        field_reprs = [
+            f"{f.name}={getattr(self, f.name)!r}"
+            for f in fields(self)
+            if f.name != "encoded_image"
+        ]
+
+        # Add the reprlib-restricted encoded_image field
+        field_reprs.append(f"encoded_image={reprlib_instance.repr(self.encoded_image)}")
+
+        # Join everything to create the repr
+        return f"{self.__class__.__name__}({', '.join(field_reprs)})"

edsl/enums.py

@@ -63,6 +63,7 @@ class InferenceServiceType(EnumWithChecks):
     AZURE = "azure"
     OLLAMA = "ollama"
     MISTRAL = "mistral"
+    TOGETHER = "together"
 
 
 service_to_api_keyname = {
@@ -76,6 +77,7 @@ service_to_api_keyname = {
     InferenceServiceType.GROQ.value: "GROQ_API_KEY",
     InferenceServiceType.BEDROCK.value: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
     InferenceServiceType.MISTRAL.value: "MISTRAL_API_KEY",
+    InferenceServiceType.TOGETHER.value: "TOGETHER_API_KEY",
 }