edsl 0.1.36.dev5__py3-none-any.whl → 0.1.36.dev6__py3-none-any.whl

edsl/agents/descriptors.py

@@ -1,86 +1,86 @@
-"""This module contains the descriptors used to set the attributes of the Agent class."""
-
-from typing import Dict
-from edsl.exceptions.agents import AgentNameError, AgentTraitKeyError
-
-
-class NameDescriptor:
-    """ABC for something."""
-
-    def __get__(self, instance, owner):
-        """Return the value of the attribute."""
-        return instance.__dict__[self.name]
-
-    def __set__(self, instance, name: str) -> None:
-        """Set the value of the attribute."""
-        instance.__dict__[self.name] = name
-
-    def __set_name__(self, owner, name: str) -> None:
-        """Set the name of the attribute."""
-        self.name = "_" + name
-
-
-class TraitsDescriptor:
-    """Traits descriptor."""
-
-    def __get__(self, instance, owner):
-        """Return the value of the attribute."""
-        return instance.__dict__[self.name]
-
-    def __set__(self, instance, traits_dict: Dict[str, str]) -> None:
-        """Set the value of the attribute."""
-        from edsl.utilities.utilities import is_valid_variable_name
-
-        for key, value in traits_dict.items():
-            if key == "name":
-                raise AgentNameError(
-                    """Trait keys cannot be 'name'. Instead, use the 'name' attribute directly e.g., 
-                    Agent(name="my_agent", traits={"trait1": "value1", "trait2": "value2"})
-                    """
-                )
-
-            if not is_valid_variable_name(key):
-                raise AgentTraitKeyError(
-                    f"""Trait keys must be valid Python identifiers (must be alphanumeric, cannot start with a number and must use underscores instead of spaces).
-                    You passed: {key}
-                    """
-                )
-
-        instance.__dict__[self.name] = traits_dict
-
-    def __set_name__(self, owner, name: str) -> None:
-        """Set the name of the attribute."""
-        self.name = name
-
-
-class CodebookDescriptor:
-    """ABC for something."""
-
-    def __get__(self, instance, owner):
-        """Return the value of the attribute."""
-        return instance.__dict__[self.name]
-
-    def __set__(self, instance, codebook_dict: Dict[str, str]) -> None:
-        """Set the value of the attribute."""
-        instance.__dict__[self.name] = codebook_dict
-
-    def __set_name__(self, owner, name: str) -> None:
-        """Set the name of the attribute."""
-        self.name = "_" + name
-
-
-class InstructionDescriptor:
-    """ABC for something."""
-
-    def __get__(self, instance, owner):
-        """Return the value of the attribute."""
-        return instance.__dict__[self.name]
-
-    def __set__(self, instance, instruction) -> None:
-        """Set the value of the attribute."""
-        instance.__dict__[self.name] = instruction
-        instance.set_instructions = instruction != instance.default_instruction
-
-    def __set_name__(self, owner, name: str) -> None:
-        """Set the name of the attribute."""
-        self.name = "_" + name
+"""This module contains the descriptors used to set the attributes of the Agent class."""
+
+from typing import Dict
+from edsl.exceptions.agents import AgentNameError, AgentTraitKeyError
+
+
+class NameDescriptor:
+    """ABC for something."""
+
+    def __get__(self, instance, owner):
+        """Return the value of the attribute."""
+        return instance.__dict__[self.name]
+
+    def __set__(self, instance, name: str) -> None:
+        """Set the value of the attribute."""
+        instance.__dict__[self.name] = name
+
+    def __set_name__(self, owner, name: str) -> None:
+        """Set the name of the attribute."""
+        self.name = "_" + name
+
+
+class TraitsDescriptor:
+    """Traits descriptor."""
+
+    def __get__(self, instance, owner):
+        """Return the value of the attribute."""
+        return instance.__dict__[self.name]
+
+    def __set__(self, instance, traits_dict: Dict[str, str]) -> None:
+        """Set the value of the attribute."""
+        from edsl.utilities.utilities import is_valid_variable_name
+
+        for key, value in traits_dict.items():
+            if key == "name":
+                raise AgentNameError(
+                    """Trait keys cannot be 'name'. Instead, use the 'name' attribute directly e.g., 
+                    Agent(name="my_agent", traits={"trait1": "value1", "trait2": "value2"})
+                    """
+                )
+
+            if not is_valid_variable_name(key):
+                raise AgentTraitKeyError(
+                    f"""Trait keys must be valid Python identifiers (must be alphanumeric, cannot start with a number and must use underscores instead of spaces).
+                    You passed: {key}
+                    """
+                )
+
+        instance.__dict__[self.name] = traits_dict
+
+    def __set_name__(self, owner, name: str) -> None:
+        """Set the name of the attribute."""
+        self.name = name
+
+
+class CodebookDescriptor:
+    """ABC for something."""
+
+    def __get__(self, instance, owner):
+        """Return the value of the attribute."""
+        return instance.__dict__[self.name]
+
+    def __set__(self, instance, codebook_dict: Dict[str, str]) -> None:
+        """Set the value of the attribute."""
+        instance.__dict__[self.name] = codebook_dict
+
+    def __set_name__(self, owner, name: str) -> None:
+        """Set the name of the attribute."""
+        self.name = "_" + name
+
+
+class InstructionDescriptor:
+    """ABC for something."""
+
+    def __get__(self, instance, owner):
+        """Return the value of the attribute."""
+        return instance.__dict__[self.name]
+
+    def __set__(self, instance, instruction) -> None:
+        """Set the value of the attribute."""
+        instance.__dict__[self.name] = instruction
+        instance.set_instructions = instruction != instance.default_instruction
+
+    def __set_name__(self, owner, name: str) -> None:
+        """Set the name of the attribute."""
+        self.name = "_" + name

edsl/agents/prompt_helpers.py

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

edsl/auto/AutoStudy.py

@@ -1,117 +1,117 @@
-from typing import Optional
-
-from edsl import Model
-from edsl.auto.StageQuestions import StageQuestions
-from edsl.auto.StagePersona import StagePersona
-from edsl.auto.StagePersonaDimensions import StagePersonaDimensions
-from edsl.auto.StagePersonaDimensionValues import StagePersonaDimensionValues
-from edsl.auto.StagePersonaDimensionValueRanges import (
-    StagePersonaDimensionValueRanges,
-)
-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
-
-
-class AutoStudy:
-    def __init__(
-        self,
-        overall_question: str,
-        population: str,
-        model: Optional["Model"] = None,
-        survey: Optional["Survey"] = None,
-        agent_list: Optional["AgentList"] = None,
-        default_num_agents=11,
-    ):
-        self.overall_question = overall_question
-        self.population = population
-        self._survey = survey
-        self._agent_list = agent_list
-        self._agent_list_generator = None
-        self._persona_mapping = None
-        self._results = None
-        self.default_num_agents = default_num_agents
-        self.model = model or Model()
-
-    @property
-    def survey(self):
-        if self._survey is None:
-            self._survey = self._create_survey()
-        return self._survey
-
-    @property
-    def persona_mapping(self):
-        if self._persona_mapping is None:
-            self._persona_mapping = self._create_persona_mapping()
-        return self._persona_mapping
-
-    @property
-    def agent_list_generator(self):
-        if self._agent_list_generator is None:
-            self._agent_list_generator = self._create_agent_list_generator()
-        return self._agent_list_generator
-
-    @property
-    def results(self):
-        if self._results is None:
-            self._results = self._create_results()
-        return self._results
-
-    def _create_survey(self):
-        survey_pipline_stages = [
-            StageQuestions,
-            StageLabelQuestions,
-            StageGenerateSurvey,
-        ]
-        survey_pipeline = gen_pipeline(survey_pipline_stages)
-        return survey_pipeline.process(
-            data=survey_pipeline.input(
-                overall_question=self.overall_question, population=self.population
-            )
-        ).survey
-
-    def _create_persona_mapping(self):
-        persona_pipeline_stages = [
-            StageQuestions,
-            StagePersona,
-            StagePersonaDimensions,
-            StagePersonaDimensionValues,
-            StagePersonaDimensionValueRanges,
-        ]
-
-        persona_pipeline = gen_pipeline(persona_pipeline_stages)
-        sample_agent_results = persona_pipeline.process(
-            persona_pipeline.input(
-                overall_question=overall_question, population=self.population
-            )
-        )
-        return sample_agent_results
-
-    def _create_agent_list_generator(self):
-        return agent_generator(
-            persona=self.persona_mapping.persona,
-            dimension_dict=self.persona_mapping.mapping,
-        )
-
-    def agent_list(self, num_agents):
-        return create_agents(
-            agent_generator=self.agent_list_generator,
-            survey=self.survey,
-            num_agents=num_agents,
-        )
-
-    def _create_results(self, num_agents=None):
-        if num_agents is None:
-            num_agents = self.default_num_agents
-        agent_list = self.agent_list(num_agents)
-        return self.survey.by(agent_list).by(self.model).run()
-
-
-if __name__ == "__main__":
-    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
+from typing import Optional
+
+from edsl import Model
+from edsl.auto.StageQuestions import StageQuestions
+from edsl.auto.StagePersona import StagePersona
+from edsl.auto.StagePersonaDimensions import StagePersonaDimensions
+from edsl.auto.StagePersonaDimensionValues import StagePersonaDimensionValues
+from edsl.auto.StagePersonaDimensionValueRanges import (
+    StagePersonaDimensionValueRanges,
+)
+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
+
+
+class AutoStudy:
+    def __init__(
+        self,
+        overall_question: str,
+        population: str,
+        model: Optional["Model"] = None,
+        survey: Optional["Survey"] = None,
+        agent_list: Optional["AgentList"] = None,
+        default_num_agents=11,
+    ):
+        self.overall_question = overall_question
+        self.population = population
+        self._survey = survey
+        self._agent_list = agent_list
+        self._agent_list_generator = None
+        self._persona_mapping = None
+        self._results = None
+        self.default_num_agents = default_num_agents
+        self.model = model or Model()
+
+    @property
+    def survey(self):
+        if self._survey is None:
+            self._survey = self._create_survey()
+        return self._survey
+
+    @property
+    def persona_mapping(self):
+        if self._persona_mapping is None:
+            self._persona_mapping = self._create_persona_mapping()
+        return self._persona_mapping
+
+    @property
+    def agent_list_generator(self):
+        if self._agent_list_generator is None:
+            self._agent_list_generator = self._create_agent_list_generator()
+        return self._agent_list_generator
+
+    @property
+    def results(self):
+        if self._results is None:
+            self._results = self._create_results()
+        return self._results
+
+    def _create_survey(self):
+        survey_pipline_stages = [
+            StageQuestions,
+            StageLabelQuestions,
+            StageGenerateSurvey,
+        ]
+        survey_pipeline = gen_pipeline(survey_pipline_stages)
+        return survey_pipeline.process(
+            data=survey_pipeline.input(
+                overall_question=self.overall_question, population=self.population
+            )
+        ).survey
+
+    def _create_persona_mapping(self):
+        persona_pipeline_stages = [
+            StageQuestions,
+            StagePersona,
+            StagePersonaDimensions,
+            StagePersonaDimensionValues,
+            StagePersonaDimensionValueRanges,
+        ]
+
+        persona_pipeline = gen_pipeline(persona_pipeline_stages)
+        sample_agent_results = persona_pipeline.process(
+            persona_pipeline.input(
+                overall_question=overall_question, population=self.population
+            )
+        )
+        return sample_agent_results
+
+    def _create_agent_list_generator(self):
+        return agent_generator(
+            persona=self.persona_mapping.persona,
+            dimension_dict=self.persona_mapping.mapping,
+        )
+
+    def agent_list(self, num_agents):
+        return create_agents(
+            agent_generator=self.agent_list_generator,
+            survey=self.survey,
+            num_agents=num_agents,
+        )
+
+    def _create_results(self, num_agents=None):
+        if num_agents is None:
+            num_agents = self.default_num_agents
+        agent_list = self.agent_list(num_agents)
+        return self.survey.by(agent_list).by(self.model).run()
+
+
+if __name__ == "__main__":
+    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