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

edsl/Base.py

@@ -47,27 +47,21 @@ 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(url=expected_parrot_url)
+        c = Coop()
         return c.create(self, description, visibility)
 
     @classmethod
-    def pull(
-        cls,
-        uuid: Optional[Union[str, UUID]] = None,
-        url: Optional[str] = None,
-        expected_parrot_url: Optional[str] = None,
-    ):
+    def pull(cls, uuid: Optional[Union[str, UUID]] = None, 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(url=expected_parrot_url)
+        coop = Coop()
         return coop.get(uuid, url, object_type)
 
     @classmethod

edsl/__init__.py

@@ -23,7 +23,6 @@ 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"
+__version__ = "0.1.33.dev1"

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,13 +2,14 @@
 
 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):
@@ -18,13 +19,9 @@ class NotApplicable(str):
         return instance
 
 
-class InvigilatorAI(InvigilatorBase):
+class InvigilatorAI(PromptConstructorMixin, 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,7 +14,6 @@ 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):
@@ -28,7 +27,16 @@ 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__(
@@ -64,11 +72,6 @@ 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",
@@ -204,6 +207,22 @@ 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
@@ -266,9 +285,9 @@ class InvigilatorBase(ABC):
 
         memory_plan = MemoryPlan(survey=survey)
         current_answers = None
-        from edsl.agents.PromptConstructor import PromptConstructor
+        from edsl.agents.PromptConstructionMixin import PromptConstructorMixin
 
-        class InvigilatorExample(InvigilatorBase):
+        class InvigilatorExample(PromptConstructorMixin, InvigilatorBase):
             """An example invigilator."""
 
             async def async_answer_question(self):

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

@@ -1,15 +1,16 @@
 from __future__ import annotations
-from typing import Dict, Any, Optional, Set
+from typing import Dict, Any, Optional
 from collections import UserList
-import enum
-
-from jinja2 import Environment, meta
 
+# from functools import reduce
 from edsl.prompts.Prompt import Prompt
-from edsl.data_transfer_models import ImageInfo
+
+# from edsl.utilities.decorators import sync_wrapper, jupyter_nb_handler
 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"
@@ -18,21 +19,6 @@ 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(" ")
 
@@ -151,7 +137,7 @@ class PromptPlan:
         }
 
 
-class PromptConstructor:
+class PromptConstructorMixin:
     """Mixin for constructing prompts for the LLM call.
 
     The pieces of a prompt are:
@@ -163,40 +149,16 @@ class PromptConstructor:
     This is mixed into the Invigilator class.
     """
 
-    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
+    prompt_plan = PromptPlan()
 
     @property
     def agent_instructions_prompt(self) -> Prompt:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
         >>> i = InvigilatorBase.example()
-        >>> i.prompt_constructor.agent_instructions_prompt
+        >>> i.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",
@@ -214,17 +176,12 @@ class PromptConstructor:
         """
         >>> from edsl.agents.InvigilatorBase import InvigilatorBase
         >>> i = InvigilatorBase.example()
-        >>> i.prompt_constructor.agent_persona_prompt
+        >>> i.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",
@@ -269,29 +226,27 @@ class PromptConstructor:
                     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.prompt_constructor.question_instructions_prompt
+        >>> i.question_instructions_prompt
         Prompt(text=\"""...
         ...
         """
         if not hasattr(self, "_question_instructions_prompt"):
             question_prompt = self.question.get_instructions(model=self.model.model)
 
-            # Are any of the scenario values ImageInfo
+            # 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
 
             question_data = self.question.data.copy()
 
@@ -299,6 +254,8 @@ class PromptConstructor:
             # 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(
@@ -312,13 +269,8 @@ class PromptConstructor:
                     self.question.question_options = question_options
 
             replacement_dict = (
-                {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
+                question_data
+                | self.scenario
                 | self.prior_answers_dict()
                 | {"agent": self.agent}
                 | {
@@ -328,10 +280,9 @@ class PromptConstructor:
                     ),
                 }
             )
-
+            # breakpoint()
             rendered_instructions = question_prompt.render(replacement_dict)
-
-            # is there anything left to render?
+            # breakpoint()
             undefined_template_variables = (
                 rendered_instructions.undefined_template_variables({})
             )
@@ -349,9 +300,7 @@ class PromptConstructor:
                     f"Question instructions still has variables: {undefined_template_variables}."
                 )
 
-            ####################################
-            # Check if question has instructions - these are instructions in a Survey that can apply to multiple follow-on questions
-            ####################################
+            # Check if question has an instructions
             relevant_instructions = self.survey.relevant_instructions(
                 self.question.question_name
             )
@@ -380,23 +329,6 @@ class PromptConstructor:
             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
@@ -431,13 +363,9 @@ class PromptConstructor:
             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,65 +1,73 @@
 """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 config var determines the run mode of the application.",
+        "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.",
     },
     "EDSL_API_TIMEOUT": {
         "default": "60",
-        "info": "This config var determines the maximum number of seconds to wait for an API call to return.",
+        "info": "This env var determines the maximum number of seconds to wait for an API call to return.",
     },
     "EDSL_BACKOFF_START_SEC": {
         "default": "1",
-        "info": "This config var determines the number of seconds to wait before retrying a failed API call.",
+        "info": "This env var determines the number of seconds to wait before retrying a failed API call.",
     },
-    "EDSL_BACKOFF_MAX_SEC": {
+    "EDSL_MAX_BACKOFF_SEC": {
         "default": "60",
-        "info": "This config var determines the maximum number of seconds to wait before retrying a failed API call.",
+        "info": "This env var determines the maximum number of seconds to wait before retrying 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_MAX_ATTEMPTS": {
+        "default": "5",
+        "info": "This env var determines the maximum number of times to retry a failed API call.",
     },
     "EDSL_DEFAULT_MODEL": {
         "default": "gpt-4o",
-        "info": "This config var holds the default model that will be used if a model is not explicitly passed.",
+        "info": "This env var holds the default model name.",
     },
-    "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_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_SERVICE_RPM_BASELINE": {
         "default": "100",
-        "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",
+        "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.",
     },
-    "EDSL_SERVICE_TPM_BASELINE": {
+    "EDSL_SERVICE_TPM_OPENAI": {
         "default": "2000000",
-        "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.",
+        "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",
     },
     "EXPECTED_PARROT_URL": {
         "default": "https://www.expectedparrot.com",
-        "info": "This config var holds the URL of the Expected Parrot API.",
+        "info": "This env var holds the URL of the Expected Parrot API.",
     },
 }
 

edsl/coop/coop.py

@@ -59,16 +59,8 @@ 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
@@ -85,7 +77,7 @@ class Coop:
             else:
                 raise Exception(f"Invalid {method=}.")
         except requests.ConnectionError:
-            raise requests.ConnectionError(f"Could not connect to the server at {url}.")
+            raise requests.ConnectionError("Could not connect to the server.")
 
         return response
 
@@ -95,7 +87,6 @@ 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,6 +1,4 @@
 from typing import NamedTuple, Dict, List, Optional, Any
-from dataclasses import dataclass, fields
-import reprlib
 
 
 class ModelInputs(NamedTuple):
@@ -47,27 +45,76 @@ class EDSLResultObjectInput(NamedTuple):
     cost: Optional[float] = None
 
 
-@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)})"
+# 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

edsl/enums.py

@@ -63,7 +63,6 @@ class InferenceServiceType(EnumWithChecks):
     AZURE = "azure"
     OLLAMA = "ollama"
     MISTRAL = "mistral"
-    TOGETHER = "together"
 
 
 service_to_api_keyname = {
@@ -77,7 +76,6 @@ 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",
 }