edsl 0.1.33.dev3__py3-none-any.whl → 0.1.34__py3-none-any.whl

edsl/scenarios/Scenario.py

@@ -2,25 +2,18 @@
 
 from __future__ import annotations
 import copy
-import base64
 import hashlib
 import os
-import reprlib
-import imghdr
-
-
 from collections import UserDict
 from typing import Union, List, Optional, Generator
 from uuid import uuid4
+
 from edsl.Base import Base
-from edsl.scenarios.ScenarioImageMixin import ScenarioImageMixin
 from edsl.scenarios.ScenarioHtmlMixin import ScenarioHtmlMixin
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
-from edsl.data_transfer_models import ImageInfo
-
 
-class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
+class Scenario(Base, UserDict, ScenarioHtmlMixin):
     """A Scenario is a dictionary of keys/values.
 
     They can be used parameterize edsl questions."""
@@ -48,12 +41,12 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
 
         return ScenarioList([copy.deepcopy(self) for _ in range(n)])
 
-    @property
-    def has_image(self) -> bool:
-        """Return whether the scenario has an image."""
-        if not hasattr(self, "_has_image"):
-            self._has_image = False
-        return self._has_image
+    # @property
+    # def has_image(self) -> bool:
+    #     """Return whether the scenario has an image."""
+    #     if not hasattr(self, "_has_image"):
+    #         self._has_image = False
+    #     return self._has_image
 
     @property
     def has_jinja_braces(self) -> bool:
@@ -63,9 +56,10 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         >>> s.has_jinja_braces
         True
         """
-        for key, value in self.items():
-            if "{{" in str(value) and "}}" in value:
-                return True
+        for _, value in self.items():
+            if isinstance(value, str):
+                if "{{" in value and "}}" in value:
+                    return True
         return False
 
     def convert_jinja_braces(
@@ -88,10 +82,6 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
                 new_scenario[key] = value
         return new_scenario
 
-    @has_image.setter
-    def has_image(self, value):
-        self._has_image = value
-
     def __add__(self, other_scenario: "Scenario") -> "Scenario":
         """Combine two scenarios by taking the union of their keys
 
@@ -114,8 +104,6 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
             data1 = copy.deepcopy(self.data)
             data2 = copy.deepcopy(other_scenario.data)
             s = Scenario(data1 | data2)
-            if self.has_image or other_scenario.has_image:
-                s._has_image = True
             return s
 
     def rename(self, replacement_dict: dict) -> "Scenario":
@@ -235,6 +223,14 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         text = requests.get(url).text
         return cls({"url": url, field_name: text})
 
+    @classmethod
+    def from_file(cls, file_path: str, field_name: str) -> "Scenario":
+        """Creates a scenario from a file."""
+        from edsl.scenarios.FileStore import FileStore
+
+        fs = FileStore(file_path)
+        return cls({field_name: fs})
+
     @classmethod
     def from_image(
         cls, image_path: str, image_name: Optional[str] = None
@@ -248,36 +244,14 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         Returns:
             Scenario: A new Scenario instance with image information.
 
-        Example:
-        >>> s = Scenario.from_image(Scenario.example_image())
-        >>> s
-        Scenario({'logo': ...})
         """
         if not os.path.exists(image_path):
             raise FileNotFoundError(f"Image file not found: {image_path}")
 
-        with open(image_path, "rb") as image_file:
-            file_content = image_file.read()
-
-        file_name = os.path.basename(image_path)
-        file_size = os.path.getsize(image_path)
-        image_format = imghdr.what(image_path) or "unknown"
-
         if image_name is None:
-            image_name = file_name.split(".")[0]
-
-        image_info = ImageInfo(
-            file_path=image_path,
-            file_name=file_name,
-            image_format=image_format,
-            file_size=file_size,
-            encoded_image=base64.b64encode(file_content).decode("utf-8"),
-        )
-
-        scenario_data = {image_name: image_info}
-        s = cls(scenario_data)
-        s.has_image = True
-        return s
+            image_name = os.path.basename(image_path).split(".")[0]
+
+        return cls.from_file(image_path, image_name)
 
     @classmethod
     def from_pdf(cls, pdf_path):

edsl/scenarios/ScenarioList.py

@@ -530,7 +530,9 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         return ScenarioList([scenario.drop(fields) for scenario in self.data])
 
     @classmethod
-    def from_list(cls, name, values) -> ScenarioList:
+    def from_list(
+        cls, name: str, values: list, func: Optional[Callable] = None
+    ) -> ScenarioList:
         """Create a ScenarioList from a list of values.
 
         Example:
@@ -538,7 +540,9 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         >>> ScenarioList.from_list('name', ['Alice', 'Bob'])
         ScenarioList([Scenario({'name': 'Alice'}), Scenario({'name': 'Bob'})])
         """
-        return cls([Scenario({name: value}) for value in values])
+        if not func:
+            func = lambda x: x
+        return cls([Scenario({name: func(value)}) for value in values])
 
     def to_dataset(self) -> "Dataset":
         """

edsl/surveys/DAG.py

@@ -11,6 +11,7 @@ class DAG(UserDict):
         """Initialize the DAG class."""
         super().__init__(data)
         self.reverse_mapping = self._create_reverse_mapping()
+        self.validate_no_cycles()
 
     def _create_reverse_mapping(self):
         """
@@ -73,12 +74,73 @@ class DAG(UserDict):
         # else:
         #     return DAG(d)
 
+    def remove_node(self, node: int) -> None:
+        """Remove a node and all its connections from the DAG."""
+        self.pop(node, None)
+        for connections in self.values():
+            connections.discard(node)
+        # Adjust remaining nodes if necessary
+        self._adjust_nodes_after_removal(node)
+
+    def _adjust_nodes_after_removal(self, removed_node: int) -> None:
+        """Adjust node indices after a node is removed."""
+        new_dag = {}
+        for node, connections in self.items():
+            new_node = node if node < removed_node else node - 1
+            new_connections = {c if c < removed_node else c - 1 for c in connections}
+            new_dag[new_node] = new_connections
+        self.clear()
+        self.update(new_dag)
+
     @classmethod
     def example(cls):
         """Return an example of the `DAG`."""
         data = {"a": ["b", "c"], "b": ["d"], "c": [], "d": []}
         return cls(data)
 
+    def detect_cycles(self):
+        """
+        Detect cycles in the DAG using depth-first search.
+
+        :return: A list of cycles if any are found, otherwise an empty list.
+        """
+        visited = set()
+        path = []
+        cycles = []
+
+        def dfs(node):
+            if node in path:
+                cycle = path[path.index(node) :]
+                cycles.append(cycle + [node])
+                return
+
+            if node in visited:
+                return
+
+            visited.add(node)
+            path.append(node)
+
+            for child in self.get(node, []):
+                dfs(child)
+
+            path.pop()
+
+        for node in self:
+            if node not in visited:
+                dfs(node)
+
+        return cycles
+
+    def validate_no_cycles(self):
+        """
+        Validate that the DAG does not contain any cycles.
+
+        :raises ValueError: If cycles are detected in the DAG.
+        """
+        cycles = self.detect_cycles()
+        if cycles:
+            raise ValueError(f"Cycles detected in the DAG: {cycles}")
+
 
 if __name__ == "__main__":
     import doctest

edsl/surveys/MemoryPlan.py

@@ -211,6 +211,32 @@ class MemoryPlan(UserDict):
         mp.add_single_memory("q1", "q0")
         return mp
 
+    def remove_question(self, question_name: str) -> None:
+        """Remove a question from the memory plan.
+
+        :param question_name: The name of the question to remove.
+        """
+        self._check_valid_question_name(question_name)
+
+        # Remove the question from survey_question_names and question_texts
+        index = self.survey_question_names.index(question_name)
+        self.survey_question_names.pop(index)
+        self.question_texts.pop(index)
+
+        # Remove the question from the memory plan if it's a focal question
+        self.pop(question_name, None)
+
+        # Remove the question from all memories where it appears as a prior question
+        for focal_question, memory in self.items():
+            memory.remove_prior_question(question_name)
+
+        # Update the DAG
+        self.dag.remove_node(index)
+
+    def remove_prior_question(self, question_name: str) -> None:
+        """Remove a prior question from the memory."""
+        self.prior_questions = [q for q in self.prior_questions if q != question_name]
+
 
 if __name__ == "__main__":
     import doctest

edsl/surveys/Rule.py

@@ -38,9 +38,29 @@ from edsl.utilities.ast_utilities import extract_variable_names
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
+class QuestionIndex:
+    def __set_name__(self, owner, name):
+        self.name = f"_{name}"
+
+    def __get__(self, obj, objtype=None):
+        return getattr(obj, self.name)
+
+    def __set__(self, obj, value):
+        if not isinstance(value, (int, EndOfSurvey.__class__)):
+            raise ValueError(f"{self.name} must be an integer or EndOfSurvey")
+        if self.name == "_next_q" and isinstance(value, int):
+            current_q = getattr(obj, "_current_q")
+            if value <= current_q:
+                raise ValueError("next_q must be greater than current_q")
+        setattr(obj, self.name, value)
+
+
 class Rule:
     """The Rule class defines a "rule" for determining the next question presented to an agent."""
 
+    current_q = QuestionIndex()
+    next_q = QuestionIndex()
+
     # Not implemented but nice to have:
     # We could potentially use the question pydantic models to check for rule conflicts, as
     # they define the potential trees through a survey.
@@ -75,6 +95,10 @@ class Rule:
         self.priority = priority
         self.before_rule = before_rule
 
+        if not self.next_q == EndOfSurvey:
+            if self.next_q <= self.current_q:
+                raise SurveyRuleSendsYouBackwardsError
+
         if not self.next_q == EndOfSurvey and self.current_q > self.next_q:
             raise SurveyRuleSendsYouBackwardsError
 

edsl/surveys/RuleCollection.py

@@ -120,13 +120,13 @@ class RuleCollection(UserList):
         :param answers: The answers to the survey questions.
 
         >>> rule_collection = RuleCollection()
-        >>> r = Rule(current_q=1, expression="True", next_q=1, priority=1, question_name_to_index={}, before_rule = True)
+        >>> r = Rule(current_q=1, expression="True", next_q=2, priority=1, question_name_to_index={}, before_rule = True)
         >>> rule_collection.add_rule(r)
         >>> rule_collection.skip_question_before_running(1, {})
         True
 
         >>> rule_collection = RuleCollection()
-        >>> r = Rule(current_q=1, expression="False", next_q=1, priority=1, question_name_to_index={}, before_rule = True)
+        >>> r = Rule(current_q=1, expression="False", next_q=2, priority=1, question_name_to_index={}, before_rule = True)
         >>> rule_collection.add_rule(r)
         >>> rule_collection.skip_question_before_running(1, {})
         False
@@ -321,6 +321,40 @@ class RuleCollection(UserList):
 
         return DAG(dict(sorted(children_to_parents.items())))
 
+    def detect_cycles(self):
+        """
+        Detect cycles in the survey rules using depth-first search.
+
+        :return: A list of cycles if any are found, otherwise an empty list.
+        """
+        dag = self.dag
+        visited = set()
+        path = []
+        cycles = []
+
+        def dfs(node):
+            if node in path:
+                cycle = path[path.index(node) :]
+                cycles.append(cycle + [node])
+                return
+
+            if node in visited:
+                return
+
+            visited.add(node)
+            path.append(node)
+
+            for child in dag.get(node, []):
+                dfs(child)
+
+            path.pop()
+
+        for node in dag:
+            if node not in visited:
+                dfs(node)
+
+        return cycles
+
     @classmethod
     def example(cls):
         """Create an example RuleCollection object."""

edsl/surveys/Survey.py

@@ -22,6 +22,10 @@ from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 from edsl.agents.Agent import Agent
 
+from edsl.surveys.instructions.InstructionCollection import InstructionCollection
+from edsl.surveys.instructions.Instruction import Instruction
+from edsl.surveys.instructions.ChangeInstruction import ChangeInstruction
+
 
 class ValidatedString(str):
     def __new__(cls, content):
@@ -32,13 +36,6 @@ class ValidatedString(str):
         return super().__new__(cls, content)
 
 
-# from edsl.surveys.Instruction import Instruction
-# from edsl.surveys.Instruction import ChangeInstruction
-from edsl.surveys.instructions.InstructionCollection import InstructionCollection
-from edsl.surveys.instructions.Instruction import Instruction
-from edsl.surveys.instructions.ChangeInstruction import ChangeInstruction
-
-
 class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
     """A collection of questions that supports skip logic."""
 
@@ -289,16 +286,52 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
     # region: Simulation methods
 
+    @classmethod
+    def random_survey(self):
+        """Create a random survey."""
+        from edsl.questions import QuestionMultipleChoice, QuestionFreeText
+        from random import choice
+
+        num_questions = 10
+        questions = []
+        for i in range(num_questions):
+            if choice([True, False]):
+                q = QuestionMultipleChoice(
+                    question_text="nothing",
+                    question_name="q_" + str(i),
+                    question_options=list(range(3)),
+                )
+                questions.append(q)
+            else:
+                questions.append(
+                    QuestionFreeText(
+                        question_text="nothing", question_name="q_" + str(i)
+                    )
+                )
+        s = Survey(questions)
+        start_index = choice(range(num_questions - 1))
+        end_index = choice(range(start_index + 1, 10))
+        s = s.add_rule(f"q_{start_index}", "True", f"q_{end_index}")
+        question_to_delete = choice(range(num_questions))
+        s.delete_question(f"q_{question_to_delete}")
+        return s
+
     def simulate(self) -> dict:
         """Simulate the survey and return the answers."""
         i = self.gen_path_through_survey()
         q = next(i)
+        num_passes = 0
         while True:
+            num_passes += 1
             try:
                 answer = q._simulate_answer()
                 q = i.send({q.question_name: answer["answer"]})
             except StopIteration:
                 break
+
+            if num_passes > 100:
+                print("Too many passes.")
+                raise Exception("Too many passes.")
         return self.answers
 
     def create_agent(self) -> "Agent":
@@ -573,7 +606,110 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
 
         return Survey(questions=self.questions + other.questions)
 
-    def add_question(self, question: QuestionBase) -> Survey:
+    def move_question(self, identifier: Union[str, int], new_index: int):
+        if isinstance(identifier, str):
+            if identifier not in self.question_names:
+                raise ValueError(
+                    f"Question name '{identifier}' does not exist in the survey."
+                )
+            index = self.question_name_to_index[identifier]
+        elif isinstance(identifier, int):
+            if identifier < 0 or identifier >= len(self.questions):
+                raise ValueError(f"Index {identifier} is out of range.")
+            index = identifier
+        else:
+            raise TypeError(
+                "Identifier must be either a string (question name) or an integer (question index)."
+            )
+
+        moving_question = self._questions[index]
+
+        new_survey = self.delete_question(index)
+        new_survey.add_question(moving_question, new_index)
+        return new_survey
+
+    def delete_question(self, identifier: Union[str, int]) -> Survey:
+        """
+        Delete a question from the survey.
+
+        :param identifier: The name or index of the question to delete.
+        :return: The updated Survey object.
+
+        >>> from edsl import QuestionMultipleChoice, Survey
+        >>> q1 = QuestionMultipleChoice(question_text="Q1", question_options=["A", "B"], question_name="q1")
+        >>> q2 = QuestionMultipleChoice(question_text="Q2", question_options=["C", "D"], question_name="q2")
+        >>> s = Survey().add_question(q1).add_question(q2)
+        >>> _ = s.delete_question("q1")
+        >>> len(s.questions)
+        1
+        >>> _ = s.delete_question(0)
+        >>> len(s.questions)
+        0
+        """
+        if isinstance(identifier, str):
+            if identifier not in self.question_names:
+                raise ValueError(
+                    f"Question name '{identifier}' does not exist in the survey."
+                )
+            index = self.question_name_to_index[identifier]
+        elif isinstance(identifier, int):
+            if identifier < 0 or identifier >= len(self.questions):
+                raise ValueError(f"Index {identifier} is out of range.")
+            index = identifier
+        else:
+            raise TypeError(
+                "Identifier must be either a string (question name) or an integer (question index)."
+            )
+
+        # Remove the question
+        deleted_question = self._questions.pop(index)
+        del self.pseudo_indices[deleted_question.question_name]
+        # del self.question_name_to_index[deleted_question.question_name]
+
+        # Update indices
+        for question_name, old_index in self.pseudo_indices.items():
+            if old_index > index:
+                self.pseudo_indices[question_name] = old_index - 1
+
+        # for question_name, old_index in self.question_name_to_index.items():
+        #     if old_index > index:
+        #         self.question_name_to_index[question_name] = old_index - 1
+
+        # Update rules
+        new_rule_collection = RuleCollection()
+        for rule in self.rule_collection:
+            if rule.current_q == index:
+                continue  # Remove rules associated with the deleted question
+            if rule.current_q > index:
+                rule.current_q -= 1
+            if rule.next_q > index:
+                rule.next_q -= 1
+
+            if rule.next_q == index:
+                if index == len(self.questions):
+                    rule.next_q = EndOfSurvey
+                else:
+                    rule.next_q = index
+                # rule.next_q = min(index, len(self.questions) - 1)
+                # continue
+
+            # if rule.next_q == index:
+            #     rule.next_q = min(
+            #         rule.next_q, len(self.questions) - 1
+            #     )  # Adjust to last question if necessary
+
+            new_rule_collection.add_rule(rule)
+        self.rule_collection = new_rule_collection
+
+        # Update memory plan if it exists
+        if hasattr(self, "memory_plan"):
+            self.memory_plan.remove_question(deleted_question.question_name)
+
+        return self
+
+    def add_question(
+        self, question: QuestionBase, index: Optional[int] = None
+    ) -> Survey:
         """
         Add a question to survey.
 
@@ -596,15 +732,51 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
             raise SurveyCreationError(
                 f"""Question name '{question.question_name}' already exists in survey. Existing names are {self.question_names}."""
             )
-        index = len(self.questions)
+        if index is None:
+            index = len(self.questions)
+
+        if index > len(self.questions):
+            raise ValueError(
+                f"Index {index} is greater than the number of questions in the survey."
+            )
+        if index < 0:
+            raise ValueError(f"Index {index} is less than 0.")
+
+        interior_insertion = index != len(self.questions)
+
+        # index = len(self.questions)
         # TODO: This is a bit ugly because the user
         # doesn't "know" about _questions - it's generated by the
         # descriptor.
-        self._questions.append(question)
+        self._questions.insert(index, question)
+
+        if interior_insertion:
+            for question_name, old_index in self.pseudo_indices.items():
+                if old_index >= index:
+                    self.pseudo_indices[question_name] = old_index + 1
 
         self.pseudo_indices[question.question_name] = index
 
+        ## Re-do question_name to index - this is done automatically
+        # for question_name, old_index in self.question_name_to_index.items():
+        #     if old_index >= index:
+        #         self.question_name_to_index[question_name] = old_index + 1
+
+        ## Need to re-do the rule collection and the indices of the questions
+
+        ## If a rule is before the insertion index and next_q is also before the insertion index, no change needed.
+        ## If the rule is before the insertion index but next_q is after the insertion index, increment the next_q by 1
+        ## If the rule is after the insertion index, increment the current_q by 1 and the next_q by 1
+
         # using index + 1 presumes there is a next question
+        if interior_insertion:
+            for rule in self.rule_collection:
+                if rule.current_q >= index:
+                    rule.current_q += 1
+                if rule.next_q >= index:
+                    rule.next_q += 1
+
+        # add a new rule
         self.rule_collection.add_rule(
             Rule(
                 current_q=index,

edsl/surveys/base.py

@@ -36,6 +36,10 @@ class EndOfSurveyParent:
         """
         return self
 
+    def __deepcopy__(self, memo):
+        # Return the same instance when deepcopy is called
+        return self
+
     def __radd__(self, other):
         """Add the object to another object.
 

{edsl-0.1.33.dev3.dist-info → edsl-0.1.34.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.33.dev3
+Version: 0.1.34
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT
@@ -21,6 +21,7 @@ Requires-Dist: anthropic (>=0.23.1,<0.24.0)
 Requires-Dist: azure-ai-inference (>=1.0.0b3,<2.0.0)
 Requires-Dist: black[jupyter] (>=24.4.2,<25.0.0)
 Requires-Dist: boto3 (>=1.34.161,<2.0.0)
+Requires-Dist: google-generativeai (>=0.8.2,<0.9.0)
 Requires-Dist: groq (>=0.9.0,<0.10.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
 Requires-Dist: json-repair (>=0.28.4,<0.29.0)