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

edsl/Base.py

@@ -10,10 +10,6 @@ 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,
@@ -27,30 +23,6 @@ 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.model import Model
+from edsl.language_models.registry import Model
 from edsl.language_models.ModelList import ModelList
 
 from edsl.results.Results import Results

edsl/__version__.py

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

edsl/agents/Agent.py

@@ -549,11 +549,12 @@ 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.
 
@@ -568,7 +569,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.model import Model
+        from edsl.language_models.registry import Model
 
         from edsl.scenarios.Scenario import Scenario
 
@@ -581,12 +582,13 @@ 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
@@ -606,7 +608,6 @@ 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.
@@ -636,10 +637,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
@@ -672,14 +673,15 @@ 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.model import Model
+        from edsl.language_models.registry import Model
         from edsl.scenarios.Scenario import Scenario
 
         model = model or Model()
@@ -692,6 +694,12 @@ 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,
@@ -702,8 +710,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
 
@@ -906,7 +914,7 @@ class Agent(Base):
         {'traits': {'age': 10, 'hair': 'brown', 'height': 5.5}, 'instruction': 'Have fun.', 'edsl_version': '...', 'edsl_class_name': 'Agent'}
         """
         d = {}
-        d["traits"] = copy.deepcopy(dict(self._traits))
+        d["traits"] = copy.deepcopy(self.traits)
         if self.name:
             d["name"] = self.name
         if self.set_instructions:

edsl/agents/Invigilator.py

@@ -13,7 +13,11 @@ if TYPE_CHECKING:
     from edsl.surveys.Survey import Survey
 
 
-NA = "Not Applicable"
+class NotApplicable(str):
+    def __new__(cls):
+        instance = super().__new__(cls, "Not Applicable")
+        instance.literal = "Not Applicable"
+        return instance
 
 
 class InvigilatorAI(InvigilatorBase):
@@ -39,9 +43,6 @@ 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:
@@ -231,13 +232,13 @@ class InvigilatorHuman(InvigilatorBase):
                 exception_occurred = e
         finally:
             data = {
-                "generated_tokens": NA,  # NotApplicable(),
+                "generated_tokens": NotApplicable(),
                 "question_name": self.question.question_name,
                 "prompts": self.get_prompts(),
-                "cached_response": NA,
-                "raw_model_response": NA,
-                "cache_used": NA,
-                "cache_key": NA,
+                "cached_response": NotApplicable(),
+                "raw_model_response": NotApplicable(),
+                "cache_used": NotApplicable(),
+                "cache_key": NotApplicable(),
                 "answer": answer,
                 "comment": comment,
                 "validated": validated,
@@ -258,10 +259,10 @@ class InvigilatorFunctional(InvigilatorBase):
             generated_tokens=str(answer),
             question_name=self.question.question_name,
             prompts=self.get_prompts(),
-            cached_response=NA,
-            raw_model_response=NA,
-            cache_used=NA,
-            cache_key=NA,
+            cached_response=NotApplicable(),
+            raw_model_response=NotApplicable(),
+            cache_used=NotApplicable(),
+            cache_key=NotApplicable(),
             answer=answer["answer"],
             comment="This is the result of a functional question.",
             validated=True,

edsl/agents/InvigilatorBase.py

@@ -14,7 +14,6 @@ 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
@@ -47,7 +46,6 @@ 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
@@ -61,7 +59,6 @@ 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()
@@ -211,7 +208,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.model import Model
+        from edsl.language_models.registry import Model
         from edsl.surveys.Survey import Survey
 
         model = Model("test", canned_response="SPAM!")

edsl/agents/PromptConstructor.py

@@ -4,56 +4,40 @@ 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 .question_option_processor import QuestionOptionProcessor
+from .QuestionOptionProcessor 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 BasePlaceholder:
-    """Base class for placeholder values when a question is not yet answered."""
+class PlaceholderAnswer:
+    """A placeholder answer for when a question is not yet answered."""
 
-    def __init__(self, placeholder_type: str = "answer"):
-        self.value = "N/A"
+    def __init__(self):
+        self.answer = "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__}:{self._type}>>"
+        return f"<<{self.__class__.__name__}>>"
 
     def __repr__(self):
-        return self.__str__()
-
-
-class PlaceholderAnswer(BasePlaceholder):
-    def __init__(self):
-        super().__init__("answer")
+        return f"<<{self.__class__.__name__}>>"
 
 
-class PlaceholderComment(BasePlaceholder):
-    def __init__(self):
-        super().__init__("comment")
+class PlaceholderComment(PlaceholderAnswer):
+    pass
 
 
-class PlaceholderGeneratedTokens(BasePlaceholder):
-    def __init__(self):
-        super().__init__("generated_tokens")
+class PlaceholderGeneratedTokens(PlaceholderAnswer):
+    pass
 
 
 class PromptConstructor:
@@ -71,8 +55,6 @@ 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
@@ -80,6 +62,7 @@ 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."""
@@ -132,8 +115,6 @@ 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:
@@ -152,25 +133,24 @@ class PromptConstructor:
         return question_name, entry_type
 
     @staticmethod
-    def _augmented_answers_dict(current_answers: dict) -> dict:
+    def _augmented_answers_dict(current_answers: dict):
         """
         >>> PromptConstructor._augmented_answers_dict({"q0": "LOVE IT!", "q0_comment": "I love school!"})
         {'q0': {'answer': 'LOVE IT!', 'comment': 'I love school!'}}
         """
-        from collections import defaultdict
-
-        d = defaultdict(dict)
+        d = {}
         for key, value in current_answers.items():
-            question_name, entry_type = (
-                PromptConstructor._extract_quetion_and_entry_type(key)
-            )
+            (
+                question_name,
+                entry_type,
+            ) = PromptConstructor._extract_quetion_and_entry_type(key)
+            if question_name not in d:
+                d[question_name] = {}
             d[question_name][entry_type] = value
-        return dict(d)
+        return d
 
     @staticmethod
-    def _add_answers(
-        answer_dict: dict, current_answers: dict
-    ) -> dict[str, "QuestionBase"]:
+    def _add_answers(answer_dict: dict, current_answers) -> 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.question_option_processor import QuestionOptionProcessor
+            from edsl.agents.QuestionOptionProcessor import QuestionOptionProcessor
 
             question_options = QuestionOptionProcessor(
                 self.prompt_constructor

edsl/auto/AutoStudy.py

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

edsl/auto/StageBase.py

@@ -1,5 +1,4 @@
 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
@@ -36,13 +35,6 @@ 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)
@@ -134,10 +126,6 @@ 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."
@@ -185,59 +173,58 @@ class StageBase(ABC):
 
 
 if __name__ == "__main__":
-    pass
-    # try:
+    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,7 +68,6 @@ if __name__ == "__main__":
             population="Consumers",
         )
     )
-
-    results = StageQuestions.func(
+    StageQuestions.func(
         overall_question="Why aren't my students studying more?", population="Tech"
     )

edsl/auto/utilities.py

@@ -88,6 +88,12 @@ 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,7 +179,6 @@ 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:
@@ -188,18 +187,11 @@ 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 install --upgrade edsl`"
+                    "Please upgrade your EDSL version to access our latest features. To upgrade, open your terminal and run `pip upgrade edsl`"
                 )
 
         if response.status_code >= 400:
-            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,
-                )
+            message = response.json().get("detail")
             # print(response.text)
             if "The API key you provided is invalid" in message and check_api_key:
                 import secrets
@@ -659,6 +651,9 @@ class Coop(CoopFunctionsMixin):
         self._resolve_server_response(response)
         return response.json()
 
+    ################
+    # Remote Inference
+    ################
     def remote_inference_create(
         self,
         job: Jobs,
@@ -769,17 +764,6 @@ 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: