edsl 0.1.39.dev2__py3-none-any.whl → 0.1.39.dev4__py3-none-any.whl

edsl/Base.py

@@ -10,6 +10,10 @@ from uuid import UUID
 class PersistenceMixin:
     """Mixin for saving and loading objects to and from files."""
 
+    def duplicate(self, add_edsl_version=False):
+        """Return a duplicate of the object."""
+        return self.from_dict(self.to_dict(add_edsl_version=False))
+
     def push(
         self,
         description: Optional[str] = None,
@@ -23,6 +27,30 @@ class PersistenceMixin:
         c = Coop(url=expected_parrot_url)
         return c.create(self, description, alias, visibility)
 
+    def to_yaml(self, add_edsl_version=False, filename: str = None) -> Union[str, None]:
+        import yaml
+
+        output = yaml.dump(self.to_dict(add_edsl_version=add_edsl_version))
+        if not filename:
+            return output
+
+        with open(filename, "w") as f:
+            f.write(output)
+
+    @classmethod
+    def from_yaml(cls, yaml_str: Optional[str] = None, filename: Optional[str] = None):
+        if yaml_str is None and filename is not None:
+            with open(filename, "r") as f:
+                yaml_str = f.read()
+                return cls.from_yaml(yaml_str=yaml_str)
+        elif yaml_str and filename is None:
+            import yaml
+
+            d = yaml.load(yaml_str, Loader=yaml.FullLoader)
+            return cls.from_dict(d)
+        else:
+            raise ValueError("Either yaml_str or filename must be provided.")
+
     def create_download_link(self):
         from tempfile import NamedTemporaryFile
         from edsl.scenarios.FileStore import FileStore

edsl/__init__.py

@@ -34,7 +34,7 @@ from edsl.scenarios.FileStore import FileStore
 
 # from edsl.utilities.interface import print_dict_with_rich
 from edsl.surveys.Survey import Survey
-from edsl.language_models.registry import Model
+from edsl.language_models.model import Model
 from edsl.language_models.ModelList import ModelList
 
 from edsl.results.Results import Results

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.39.dev2"
+__version__ = "0.1.39.dev4"

edsl/agents/Agent.py

@@ -549,12 +549,11 @@ class Agent(Base):
         survey: Optional["Survey"] = None,
         scenario: Optional["Scenario"] = None,
         model: Optional["LanguageModel"] = None,
-        #        debug: bool = False,
         memory_plan: Optional["MemoryPlan"] = None,
         current_answers: Optional[dict] = None,
         iteration: int = 1,
-        #        sidecar_model=None,
         raise_validation_errors: bool = True,
+        key_lookup: Optional["KeyLookup"] = None,
     ) -> "InvigilatorBase":
         """Create an Invigilator.
 
@@ -569,7 +568,7 @@ class Agent(Base):
         An invigator is an object that is responsible for administering a question to an agent and
         recording the responses.
         """
-        from edsl.language_models.registry import Model
+        from edsl.language_models.model import Model
 
         from edsl.scenarios.Scenario import Scenario
 
@@ -582,13 +581,12 @@ class Agent(Base):
             scenario=scenario,
             survey=survey,
             model=model,
-            #            debug=debug,
             memory_plan=memory_plan,
             current_answers=current_answers,
             iteration=iteration,
             cache=cache,
-            #           sidecar_model=sidecar_model,
             raise_validation_errors=raise_validation_errors,
+            key_lookup=key_lookup,
         )
         if hasattr(self, "validate_response"):
             invigilator.validate_response = self.validate_response
@@ -608,6 +606,7 @@ class Agent(Base):
         memory_plan: Optional[MemoryPlan] = None,
         current_answers: Optional[dict] = None,
         iteration: int = 0,
+        key_lookup: Optional["KeyLookup"] = None,
     ) -> AgentResponseDict:
         """
         Answer a posed question.
@@ -637,10 +636,10 @@ class Agent(Base):
             scenario=scenario,
             survey=survey,
             model=model,
-            #            debug=debug,
             memory_plan=memory_plan,
             current_answers=current_answers,
             iteration=iteration,
+            key_lookup=key_lookup,
         )
         response: AgentResponseDict = await invigilator.async_answer_question()
         return response
@@ -673,15 +672,14 @@ class Agent(Base):
         scenario: Optional[Scenario] = None,
         model: Optional[LanguageModel] = None,
         survey: Optional[Survey] = None,
-        #        debug: bool = False,
         memory_plan: Optional[MemoryPlan] = None,
         current_answers: Optional[dict] = None,
         iteration: int = 0,
-        #        sidecar_model=None,
         raise_validation_errors: bool = True,
+        key_lookup: Optional["KeyLookup"] = None,
     ) -> "InvigilatorBase":
         """Create an Invigilator."""
-        from edsl.language_models.registry import Model
+        from edsl.language_models.model import Model
         from edsl.scenarios.Scenario import Scenario
 
         model = model or Model()
@@ -694,12 +692,6 @@ class Agent(Base):
 
         invigilator_class = self._get_invigilator_class(question)
 
-        # if sidecar_model is not None:
-        #     # this is the case when a 'simple' model is being used
-        #     # from edsl.agents.Invigilator import InvigilatorSidecar
-        #     # invigilator_class = InvigilatorSidecar
-        #     raise DeprecationWarning("Sidecar models are deprecated.")
-
         invigilator = invigilator_class(
             self,
             question=question,
@@ -710,8 +702,8 @@ class Agent(Base):
             current_answers=current_answers,
             iteration=iteration,
             cache=cache,
-            #            sidecar_model=sidecar_model,
             raise_validation_errors=raise_validation_errors,
+            key_lookup=key_lookup,
         )
         return invigilator
 

edsl/agents/Invigilator.py

@@ -13,11 +13,7 @@ if TYPE_CHECKING:
     from edsl.surveys.Survey import Survey
 
 
-class NotApplicable(str):
-    def __new__(cls):
-        instance = super().__new__(cls, "Not Applicable")
-        instance.literal = "Not Applicable"
-        return instance
+NA = "Not Applicable"
 
 
 class InvigilatorAI(InvigilatorBase):
@@ -43,6 +39,9 @@ class InvigilatorAI(InvigilatorBase):
         params.update({"iteration": self.iteration, "cache": self.cache})
         params.update({"invigilator": self})
 
+        if self.key_lookup:
+            self.model.set_key_lookup(self.key_lookup)
+
         return await self.model.async_get_response(**params)
 
     def store_response(self, agent_response_dict: AgentResponseDict) -> None:
@@ -232,13 +231,13 @@ class InvigilatorHuman(InvigilatorBase):
                 exception_occurred = e
         finally:
             data = {
-                "generated_tokens": NotApplicable(),
+                "generated_tokens": NA,  # NotApplicable(),
                 "question_name": self.question.question_name,
                 "prompts": self.get_prompts(),
-                "cached_response": NotApplicable(),
-                "raw_model_response": NotApplicable(),
-                "cache_used": NotApplicable(),
-                "cache_key": NotApplicable(),
+                "cached_response": NA,
+                "raw_model_response": NA,
+                "cache_used": NA,
+                "cache_key": NA,
                 "answer": answer,
                 "comment": comment,
                 "validated": validated,
@@ -259,10 +258,10 @@ class InvigilatorFunctional(InvigilatorBase):
             generated_tokens=str(answer),
             question_name=self.question.question_name,
             prompts=self.get_prompts(),
-            cached_response=NotApplicable(),
-            raw_model_response=NotApplicable(),
-            cache_used=NotApplicable(),
-            cache_key=NotApplicable(),
+            cached_response=NA,
+            raw_model_response=NA,
+            cache_used=NA,
+            cache_key=NA,
             answer=answer["answer"],
             comment="This is the result of a functional question.",
             validated=True,

edsl/agents/InvigilatorBase.py

@@ -14,6 +14,7 @@ if TYPE_CHECKING:
     from edsl.language_models.LanguageModel import LanguageModel
     from edsl.surveys.Survey import Survey
     from edsl.agents.Agent import Agent
+    from edsl.language_models.key_management.KeyLookup import KeyLookup
 
 from edsl.data_transfer_models import EDSLResultObjectInput
 from edsl.agents.PromptConstructor import PromptConstructor
@@ -46,6 +47,7 @@ class InvigilatorBase(ABC):
         additional_prompt_data: Optional[dict] = None,
         raise_validation_errors: Optional[bool] = True,
         prompt_plan: Optional["PromptPlan"] = None,
+        key_lookup: Optional["KeyLookup"] = None,
     ):
         """Initialize a new Invigilator."""
         self.agent = agent
@@ -59,6 +61,7 @@ class InvigilatorBase(ABC):
         self.cache = cache
         self.survey = survey
         self.raise_validation_errors = raise_validation_errors
+        self.key_lookup = key_lookup
 
         if prompt_plan is None:
             self.prompt_plan = PromptPlan()
@@ -208,7 +211,7 @@ class InvigilatorBase(ABC):
         from edsl.agents.Agent import Agent
         from edsl.scenarios.Scenario import Scenario
         from edsl.surveys.MemoryPlan import MemoryPlan
-        from edsl.language_models.registry import Model
+        from edsl.language_models.model import Model
         from edsl.surveys.Survey import Survey
 
         model = Model("test", canned_response="SPAM!")

edsl/agents/PromptConstructor.py

@@ -4,40 +4,56 @@ from functools import cached_property
 
 from edsl.prompts.Prompt import Prompt
 
+from dataclasses import dataclass
+
 from .prompt_helpers import PromptPlan
 from .QuestionTemplateReplacementsBuilder import (
     QuestionTemplateReplacementsBuilder,
 )
-from .QuestionOptionProcessor import QuestionOptionProcessor
+from .question_option_processor import QuestionOptionProcessor
 
 if TYPE_CHECKING:
     from edsl.agents.InvigilatorBase import InvigilatorBase
     from edsl.questions.QuestionBase import QuestionBase
+    from edsl.agents.Agent import Agent
+    from edsl.surveys.Survey import Survey
+    from edsl.language_models.LanguageModel import LanguageModel
+    from edsl.surveys.MemoryPlan import MemoryPlan
+    from edsl.questions.QuestionBase import QuestionBase
+    from edsl.scenarios.Scenario import Scenario
 
 
-class PlaceholderAnswer:
-    """A placeholder answer for when a question is not yet answered."""
+class BasePlaceholder:
+    """Base class for placeholder values when a question is not yet answered."""
 
-    def __init__(self):
-        self.answer = "N/A"
+    def __init__(self, placeholder_type: str = "answer"):
+        self.value = "N/A"
         self.comment = "Will be populated by prior answer"
+        self._type = placeholder_type
 
     def __getitem__(self, index):
         return ""
 
     def __str__(self):
-        return f"<<{self.__class__.__name__}>>"
+        return f"<<{self.__class__.__name__}:{self._type}>>"
 
     def __repr__(self):
-        return f"<<{self.__class__.__name__}>>"
+        return self.__str__()
+
+
+class PlaceholderAnswer(BasePlaceholder):
+    def __init__(self):
+        super().__init__("answer")
 
 
-class PlaceholderComment(PlaceholderAnswer):
-    pass
+class PlaceholderComment(BasePlaceholder):
+    def __init__(self):
+        super().__init__("comment")
 
 
-class PlaceholderGeneratedTokens(PlaceholderAnswer):
-    pass
+class PlaceholderGeneratedTokens(BasePlaceholder):
+    def __init__(self):
+        super().__init__("generated_tokens")
 
 
 class PromptConstructor:
@@ -55,6 +71,8 @@ class PromptConstructor:
         self, invigilator: "InvigilatorBase", prompt_plan: Optional["PromptPlan"] = None
     ):
         self.invigilator = invigilator
+        self.prompt_plan = prompt_plan or PromptPlan()
+
         self.agent = invigilator.agent
         self.question = invigilator.question
         self.scenario = invigilator.scenario
@@ -62,7 +80,6 @@ class PromptConstructor:
         self.model = invigilator.model
         self.current_answers = invigilator.current_answers
         self.memory_plan = invigilator.memory_plan
-        self.prompt_plan = prompt_plan or PromptPlan()
 
     def get_question_options(self, question_data):
         """Get the question options."""
@@ -115,6 +132,8 @@ class PromptConstructor:
         ('q0', 'comment')
         >>> PromptConstructor._extract_quetion_and_entry_type("q0_alternate_generated_tokens")
         ('q0_alternate', 'generated_tokens')
+        >>> PromptConstructor._extract_quetion_and_entry_type("q0_alt_comment")
+        ('q0_alt', 'comment')
         """
         split_list = key_entry.rsplit("_", maxsplit=1)
         if len(split_list) == 1:
@@ -133,24 +152,25 @@ class PromptConstructor:
         return question_name, entry_type
 
     @staticmethod
-    def _augmented_answers_dict(current_answers: dict):
+    def _augmented_answers_dict(current_answers: dict) -> dict:
         """
         >>> PromptConstructor._augmented_answers_dict({"q0": "LOVE IT!", "q0_comment": "I love school!"})
         {'q0': {'answer': 'LOVE IT!', 'comment': 'I love school!'}}
         """
-        d = {}
+        from collections import defaultdict
+
+        d = defaultdict(dict)
         for key, value in current_answers.items():
-            (
-                question_name,
-                entry_type,
-            ) = PromptConstructor._extract_quetion_and_entry_type(key)
-            if question_name not in d:
-                d[question_name] = {}
+            question_name, entry_type = (
+                PromptConstructor._extract_quetion_and_entry_type(key)
+            )
             d[question_name][entry_type] = value
-        return d
+        return dict(d)
 
     @staticmethod
-    def _add_answers(answer_dict: dict, current_answers) -> dict[str, "QuestionBase"]:
+    def _add_answers(
+        answer_dict: dict, current_answers: dict
+    ) -> dict[str, "QuestionBase"]:
         """
         >>> from edsl import QuestionFreeText
         >>> d = {"q0": QuestionFreeText(question_text="Do you like school?", question_name = "q0")}

edsl/agents/QuestionInstructionPromptBuilder.py

@@ -51,7 +51,7 @@ class QuestionInstructionPromptBuilder:
             Dict: Enriched prompt data
         """
         if "question_options" in prompt_data["data"]:
-            from edsl.agents.QuestionOptionProcessor import QuestionOptionProcessor
+            from edsl.agents.question_option_processor import QuestionOptionProcessor
 
             question_options = QuestionOptionProcessor(
                 self.prompt_constructor

edsl/auto/AutoStudy.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
 from edsl import Model
 from edsl.auto.StageQuestions import StageQuestions
@@ -11,10 +11,12 @@ from edsl.auto.StagePersonaDimensionValueRanges import (
 from edsl.auto.StageLabelQuestions import StageLabelQuestions
 from edsl.auto.StageGenerateSurvey import StageGenerateSurvey
 
-# from edsl.auto.StageBase import gen_pipeline
-
 from edsl.auto.utilities import agent_generator, create_agents, gen_pipeline
 
+if TYPE_CHECKING:
+    from edsl.surveys.Survey import Survey
+    from edsl.agents.AgentList import AgentList
+
 
 class AutoStudy:
     def __init__(
@@ -24,8 +26,10 @@ class AutoStudy:
         model: Optional["Model"] = None,
         survey: Optional["Survey"] = None,
         agent_list: Optional["AgentList"] = None,
-        default_num_agents=11,
+        default_num_agents: int = 11,
     ):
+        """AutoStudy class for generating surveys and agents."""
+
         self.overall_question = overall_question
         self.population = population
         self._survey = survey
@@ -36,6 +40,15 @@ class AutoStudy:
         self.default_num_agents = default_num_agents
         self.model = model or Model()
 
+    def to_dict(self):
+        return {
+            "overall_question": self.overall_question,
+            "population": self.population,
+            "survey": self.survey.to_dict(),
+            "persona_mapping": self.persona_mapping.to_dict(),
+            "results": self.results.to_dict(),
+        }
+
     @property
     def survey(self):
         if self._survey is None:
@@ -111,7 +124,7 @@ class AutoStudy:
 
 
 if __name__ == "__main__":
-    overall_question = "Should online platforms be regulated with respect to selling electric scooters?"
+    overall_question = "I have an open source Python library for working with LLMs. What are some ways we can market this to others?"
     auto_study = AutoStudy(overall_question, population="US Adults")
 
     results = auto_study.results

edsl/auto/StageBase.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+import json
 from typing import Dict, List, Any, TypeVar, Generator, Dict, Callable
 from dataclasses import dataclass, field, KW_ONLY, fields, asdict
 import textwrap
@@ -35,6 +36,13 @@ class FlowDataBase:
     sent_to_stage_name: str = field(default_factory=str)
     came_from_stage_name: str = field(default_factory=str)
 
+    def to_dict(self):
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
     def __getitem__(self, key):
         """Allows dictionary-style getting."""
         return getattr(self, key)
@@ -126,6 +134,10 @@ class StageBase(ABC):
         else:
             self.next_stage = None
 
+    @classmethod
+    def function_parameters(self):
+        return fields(self.input)
+
     @classmethod
     def func(cls, **kwargs):
         "This provides a shortcut for running a stage by passing keyword arguments to the input function."
@@ -173,58 +185,59 @@ class StageBase(ABC):
 
 
 if __name__ == "__main__":
-    try:
+    pass
+    # try:
 
-        class StageMissing(StageBase):
-            def handle_data(self, data):
-                return data
+    #     class StageMissing(StageBase):
+    #         def handle_data(self, data):
+    #             return data
 
-    except NotImplementedError as e:
-        print(e)
-    else:
-        raise Exception("Should have raised NotImplementedError")
+    # except NotImplementedError as e:
+    #     print(e)
+    # else:
+    #     raise Exception("Should have raised NotImplementedError")
 
-    try:
+    # try:
 
-        class StageMissingInput(StageBase):
-            output = FlowDataBase
+    #     class StageMissingInput(StageBase):
+    #         output = FlowDataBase
 
-    except NotImplementedError as e:
-        print(e)
+    # except NotImplementedError as e:
+    #     print(e)
 
-    else:
-        raise Exception("Should have raised NotImplementedError")
+    # else:
+    #     raise Exception("Should have raised NotImplementedError")
 
-    @dataclass
-    class MockInputOutput(FlowDataBase):
-        text: str
+    # @dataclass
+    # class MockInputOutput(FlowDataBase):
+    #     text: str
 
-    class StageTest(StageBase):
-        input = MockInputOutput
-        output = MockInputOutput
+    # class StageTest(StageBase):
+    #     input = MockInputOutput
+    #     output = MockInputOutput
 
-        def handle_data(self, data):
-            return self.output(text=data["text"] + "processed")
+    #     def handle_data(self, data):
+    #         return self.output(text=data["text"] + "processed")
 
-    result = StageTest().process(MockInputOutput(text="Hello world!"))
-    print(result.text)
+    # result = StageTest().process(MockInputOutput(text="Hello world!"))
+    # print(result.text)
 
-    pipeline = StageTest(next_stage=StageTest(next_stage=StageTest()))
-    result = pipeline.process(MockInputOutput(text="Hello world!"))
-    print(result.text)
+    # pipeline = StageTest(next_stage=StageTest(next_stage=StageTest()))
+    # result = pipeline.process(MockInputOutput(text="Hello world!"))
+    # print(result.text)
 
-    class BadMockInput(FlowDataBase):
-        text: str
-        other: str
+    # class BadMockInput(FlowDataBase):
+    #     text: str
+    #     other: str
 
-    class StageBad(StageBase):
-        input = BadMockInput
-        output = BadMockInput
+    # class StageBad(StageBase):
+    #     input = BadMockInput
+    #     output = BadMockInput
 
-        def handle_data(self, data):
-            return self.output(text=data["text"] + "processed")
+    #     def handle_data(self, data):
+    #         return self.output(text=data["text"] + "processed")
 
-    try:
-        pipeline = StageTest(next_stage=StageBad(next_stage=StageTest()))
-    except ExceptionPipesDoNotFit as e:
-        print(e)
+    # try:
+    #     pipeline = StageTest(next_stage=StageBad(next_stage=StageTest()))
+    # except ExceptionPipesDoNotFit as e:
+    #     print(e)

edsl/auto/StageQuestions.py

@@ -68,6 +68,7 @@ if __name__ == "__main__":
             population="Consumers",
         )
     )
-    StageQuestions.func(
+
+    results = StageQuestions.func(
         overall_question="Why aren't my students studying more?", population="Tech"
     )

edsl/auto/utilities.py

@@ -88,12 +88,6 @@ def agent_eligibility(
         q_eligibility(model=model, questions=questions, persona=persona, cache=cache)
         == "Yes"
     )
-    # results = (
-    #     q.by(model)
-    #     .by(Scenario({"questions": questions, "persona": persona}))
-    #     .run(cache=cache)
-    # )
-    # return results.select("eligibility").first() == "Yes"
 
 
 def gen_agent_traits(dimension_dict: dict, seed_value: Optional[str] = None):

edsl/coop/coop.py

@@ -179,6 +179,7 @@ class Coop(CoopFunctionsMixin):
         Check the response from the server and raise errors as appropriate.
         """
         # Get EDSL version from header
+        # breakpoint()
         server_edsl_version = response.headers.get("X-EDSL-Version")
 
         if server_edsl_version:
@@ -187,11 +188,18 @@ class Coop(CoopFunctionsMixin):
                 server_version_str=server_edsl_version,
             ):
                 print(
-                    "Please upgrade your EDSL version to access our latest features. To upgrade, open your terminal and run `pip upgrade edsl`"
+                    "Please upgrade your EDSL version to access our latest features. To upgrade, open your terminal and run `pip install --upgrade edsl`"
                 )
 
         if response.status_code >= 400:
-            message = response.json().get("detail")
+            try:
+                message = response.json().get("detail")
+            except json.JSONDecodeError:
+                raise CoopServerResponseError(
+                    f"Server returned status code {response.status_code}."
+                    "JSON response could not be decoded.",
+                    "The server response was: " + response.text,
+                )
             # print(response.text)
             if "The API key you provided is invalid" in message and check_api_key:
                 import secrets
@@ -651,9 +659,6 @@ class Coop(CoopFunctionsMixin):
         self._resolve_server_response(response)
         return response.json()
 
-    ################
-    # Remote Inference
-    ################
     def remote_inference_create(
         self,
         job: Jobs,
@@ -764,6 +769,17 @@ class Coop(CoopFunctionsMixin):
             }
         )
 
+    def get_running_jobs(self) -> list[str]:
+        """
+        Get a list of currently running job IDs.
+
+        Returns:
+            list[str]: List of running job UUIDs
+        """
+        response = self._send_server_request(uri="jobs/status", method="GET")
+        self._resolve_server_response(response)
+        return response.json().get("running_jobs", [])
+
     def remote_inference_cost(
         self, input: Union[Jobs, Survey], iterations: int = 1
     ) -> int: