edsl 0.1.27.dev2__py3-none-any.whl → 0.1.28__py3-none-any.whl

edsl/agents/InvigilatorBase.py

@@ -27,13 +27,13 @@ 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='')
+    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='
+    Prompt(text=\"""
             Before the question you are now answering, you already answered the following question(s):
     ...
     """
@@ -67,7 +67,7 @@ class InvigilatorBase(ABC):
         """Return a string representation of the Invigilator.
 
         >>> InvigilatorBase.example().__repr__()
-        "InvigilatorExample(...)"
+        'InvigilatorExample(...)'
 
         """
         return f"{self.__class__.__name__}(agent={repr(self.agent)}, question={repr(self.question)}, scneario={repr(self.scenario)}, model={repr(self.model)}, memory_plan={repr(self.memory_plan)}, current_answers={repr(self.current_answers)}, iteration{repr(self.iteration)}, additional_prompt_data={repr(self.additional_prompt_data)}, cache={repr(self.cache)}, sidecarmodel={repr(self.sidecar_model)})"
@@ -89,7 +89,7 @@ class InvigilatorBase(ABC):
         """Return the prompt used.
 
         >>> InvigilatorBase.example().get_prompts()
-        {'user_prompt': Prompt(text='NA'), 'system_prompt': Prompt(text='NA')}
+        {'user_prompt': Prompt(text=\"""NA\"""), 'system_prompt': Prompt(text=\"""NA\""")}
         """
         return {
             "user_prompt": Prompt("NA"),
@@ -133,7 +133,7 @@ class InvigilatorBase(ABC):
         """Return an example invigilator.
 
         >>> InvigilatorBase.example()
-        InvigilatorExample(agent=Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5}), question=Question('multiple_choice', question_name = 'how_feeling', question_text = 'How are you?', question_options = ['Good', 'Great', 'OK', 'Bad']), scneario=Scenario({'persona': 'A reseacher studying whether LLMs can be used to generate surveys.'}), model=Model(model_name = 'test', temperature = 0.5), memory_plan={}, current_answers=None, iteration1, additional_prompt_data=None, cache=None, sidecarmodel=None)
+        InvigilatorExample(...)
 
         """
         from edsl.agents.Agent import Agent

edsl/agents/descriptors.py

@@ -40,7 +40,9 @@ class TraitsDescriptor:
 
             if not is_valid_variable_name(key):
                 raise AgentTraitKeyError(
-                    "Trait keys must be valid Python identifiers (must be alphanumeric, cannot start with a number and must use underscores instead of spaces)."
+                    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

edsl/conjure/AgentConstructionMixin.py

@@ -0,0 +1,152 @@
+import random
+from typing import Generator, List, Optional, Union, Callable
+from edsl.agents.Agent import Agent
+from edsl.agents.AgentList import AgentList
+from edsl.questions import QuestionBase
+from edsl.results.Results import Results
+
+
+class AgentConstructionMixin:
+    def agent(self, index) -> Agent:
+        """Return an agent constructed from the data.
+
+        :param index: The index of the agent to construct.
+
+        >>> from edsl.conjure.InputData import InputDataABC
+        >>> id = InputDataABC.example()
+        >>> id.agent(0)
+        Agent(traits = {'morning': '1', 'feeling': '3'}, codebook = {'morning': 'how are you doing this morning?', 'feeling': 'how are you feeling?'})
+
+
+        """
+        responses = [responses[index] for responses in self.raw_data]
+        traits = {qn: r for qn, r in zip(self.question_names, responses)}
+
+        a = Agent(traits=traits, codebook=self.names_to_texts)
+
+        def construct_answer_dict_function(traits: dict) -> Callable:
+            def func(self, question: "QuestionBase", scenario=None):
+                return traits.get(question.question_name, None)
+
+            return func
+
+        a.add_direct_question_answering_method(construct_answer_dict_function(traits))
+        return a
+
+    def _agents(self, indices) -> Generator[Agent, None, None]:
+        """Return a generator of agents, one for each index."""
+        for idx in indices:
+            yield self.agent(idx)
+
+    def to_agent_list(
+        self,
+        indices: Optional[List] = None,
+        sample_size: int = None,
+        seed: str = "edsl",
+        remove_direct_question_answering_method: bool = True,
+    ) -> AgentList:
+        """Return an AgentList from the data.
+
+        :param indices: The indices of the agents to include.
+        :param sample_size: The number of agents to sample.
+        :param seed: The seed for the random number generator.
+
+        >>> from edsl.conjure.InputData import InputDataABC
+        >>> id = InputDataABC.example()
+        >>> al = id.to_agent_list()
+        >>> len(al) == id.num_observations
+        True
+        >>> al = id.to_agent_list(indices = [0, 1, 2])
+        Traceback (most recent call last):
+        ...
+        ValueError: Index 2 is greater than the number of agents 2.
+        """
+        if indices and (sample_size or seed != "edsl"):
+            raise ValueError(
+                "You cannot pass both indices and sample_size/seed, as these are mutually exclusive."
+            )
+
+        if indices:
+            if len(indices) == 0:
+                raise ValueError("Indices must be a non-empty list.")
+            if max(indices) >= self.num_observations:
+                raise ValueError(
+                    f"Index {max(indices)} is greater than the number of agents {self.num_observations}."
+                )
+            if min(indices) < 0:
+                raise ValueError(f"Index {min(indices)} is less than 0.")
+
+        if indices is None:
+            if sample_size is None:
+                indices = range(self.num_observations)
+            else:
+                if sample_size > self.num_observations:
+                    raise ValueError(
+                        f"Sample size {sample_size} is greater than the number of agents {self.num_observations}."
+                    )
+                random.seed(seed)
+                indices = random.sample(range(self.num_observations), sample_size)
+
+        agents = list(self._agents(indices))
+        if remove_direct_question_answering_method:
+            for a in agents:
+                a.remove_direct_question_answering_method()
+        return AgentList(agents)
+
+    def to_results(
+        self,
+        indices: Optional[List] = None,
+        sample_size: int = None,
+        seed: str = "edsl",
+        dryrun=False,
+    ) -> Union[Results, None]:
+        """Return the results of the survey.
+
+        :param indices: The indices of the agents to include.
+        :param sample_size: The number of agents to sample.
+        :param seed: The seed for the random number generator.
+        :param dryrun: If True, the survey will not be run, but the time to run it will be printed.
+
+        >>> from edsl.conjure.InputData import InputDataABC
+        >>> id = InputDataABC.example()
+        >>> r = id.to_results()
+        >>> len(r) == id.num_observations
+        True
+        """
+        agent_list = self.to_agent_list(
+            indices=indices,
+            sample_size=sample_size,
+            seed=seed,
+            remove_direct_question_answering_method=False,
+        )
+        DRYRUN_SAMPLE = 30
+        survey = self.to_survey()
+        if dryrun:
+            import time
+
+            start = time.time()
+            _ = survey.by(agent_list.sample(DRYRUN_SAMPLE)).run()
+            end = time.time()
+            print(f"Time to run {DRYRUN_SAMPLE} agents (s): {round(end - start, 2)}")
+            time_per_agent = (end - start) / DRYRUN_SAMPLE
+            full_sample_time = time_per_agent * len(agent_list)
+            if full_sample_time < 60:
+                print(
+                    f"Full sample will take about {round(full_sample_time, 2)} seconds."
+                )
+            if full_sample_time > 60 and full_sample_time < 3600:
+                print(
+                    f"Full sample will take about {round(full_sample_time / 60, 2)} minutes."
+                )
+            if full_sample_time > 3600:
+                print(
+                    f"Full sample will take about {round(full_sample_time / 3600, 2)} hours."
+                )
+            return None
+        return survey.by(agent_list).run()
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/conjure/Conjure.py

@@ -0,0 +1,56 @@
+from typing import List, Optional, Dict, Callable
+
+
+class Conjure:
+    def __new__(cls, datafile_name: str, *args, **kwargs):
+        if datafile_name.endswith(".csv"):
+            from edsl.conjure.InputDataCSV import InputDataCSV
+
+            return InputDataCSV(datafile_name, *args, **kwargs)
+        elif datafile_name.endswith(".sav"):
+            from edsl.conjure.InputDataSPSS import InputDataSPSS
+
+            return InputDataSPSS(datafile_name, *args, **kwargs)
+        elif datafile_name.endswith(".dta"):
+            from edsl.conjure.InputDataStata import InputDataStata
+
+            return InputDataStata(datafile_name, *args, **kwargs)
+        else:
+            raise ValueError("Unsupported file type")
+
+    def __init__(
+        self,
+        datafile_name: str,
+        config: Optional[dict] = None,
+        naming_function: Optional[Callable] = None,
+        raw_data: Optional[List] = None,
+        question_names: Optional[List[str]] = None,
+        question_texts: Optional[List[str]] = None,
+        answer_codebook: Optional[Dict] = None,
+        question_types: Optional[List[str]] = None,
+        question_options: Optional[List] = None,
+        order_options=False,
+        question_name_repair_func: Callable = None,
+    ):
+        # The __init__ method in Conjure won't be called because __new__ returns a different class instance.
+        pass
+
+
+if __name__ == "__main__":
+    pass
+    # import glob
+
+    # for file in glob.glob("examples/*"):
+    #     if file.endswith(".txt"):
+    #         continue
+    #     print("\n\n")
+    #     print("Now processing:", file)
+    #     conjure_instance = Conjure(file)
+    #     print(conjure_instance)
+    #     conjure_instance.to_results(dryrun=True)
+    #     print("\n\n")
+
+    #     # c = Conjure("mayors.sav")
+    #     # al = c.to_agent_list()
+    #     # s = c.to_survey()
+    #     # r = c.results()