edsl 0.1.29.dev3__py3-none-any.whl → 0.1.30__py3-none-any.whl

edsl/questions/QuestionFunctional.py

@@ -1,16 +1,37 @@
 from typing import Optional, Callable
-from edsl.questions.QuestionBase import QuestionBase
-from edsl.questions.descriptors import FunctionDescriptor
 import inspect
 
 from edsl.questions.QuestionBase import QuestionBase
-from edsl.questions.descriptors import FunctionDescriptor
 
 from edsl.utilities.restricted_python import create_restricted_function
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 class QuestionFunctional(QuestionBase):
-    """A special type of question that is *not* answered by an LLM."""
+    """A special type of question that is *not* answered by an LLM.
+
+    >>> from edsl import Scenario, Agent
+
+    # Create an instance of QuestionFunctional with the new function
+    >>> question = QuestionFunctional.example()
+
+    # Activate and test the function
+    >>> question.activate()
+    >>> scenario = Scenario({"numbers": [1, 2, 3, 4, 5]})
+    >>> agent = Agent(traits={"multiplier": 10})
+    >>> results = question.by(scenario).by(agent).run()
+    >>> results.select("answer.*").to_list()[0] == 150
+    True
+
+    # Serialize the question to a dictionary
+
+    >>> from edsl.questions.QuestionBase import QuestionBase
+    >>> new_question = QuestionBase.from_dict(question.to_dict())
+    >>> results = new_question.by(scenario).by(agent).run()
+    >>> results.select("answer.*").to_list()[0] == 150
+    True
+
+    """
 
     question_type = "functional"
     default_instructions = ""
@@ -76,6 +97,7 @@ class QuestionFunctional(QuestionBase):
         """Required by Question, but not used by QuestionFunctional."""
         raise NotImplementedError
 
+    @add_edsl_version
     def to_dict(self):
         return {
             "question_name": self.question_name,
@@ -116,4 +138,11 @@ def main():
     scenario = Scenario({"numbers": [1, 2, 3, 4, 5]})
     agent = Agent(traits={"multiplier": 10})
     results = question.by(scenario).by(agent).run()
-    print(results)
+    assert results.select("answer.*").to_list()[0] == 150
+
+
+if __name__ == "__main__":
+    # main()
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/questions/QuestionList.py

@@ -5,9 +5,6 @@ from typing import Any, Optional, Union
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import IntegerOrNoneDescriptor
 
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
-
 
 class QuestionList(QuestionBase):
     """This question prompts the agent to answer by providing a list of items as comma-separated strings."""
@@ -42,13 +39,15 @@ class QuestionList(QuestionBase):
         self._validate_answer_list(answer)
         return answer
 
-    def _translate_answer_code_to_answer(self, answer, scenario: Scenario = None):
+    def _translate_answer_code_to_answer(self, answer, scenario: "Scenario" = None):
         """There is no answer code."""
         return answer
 
     def _simulate_answer(self, human_readable: bool = True):
         """Simulate a valid answer for debugging purposes (what the validator expects)."""
         num_items = random.randint(1, self.max_list_items or 2)
+        from edsl.utilities.utilities import random_string
+
         return {"answer": [random_string() for _ in range(num_items)]}
 
     @property

edsl/questions/QuestionMultipleChoice.py

@@ -1,17 +1,20 @@
 from __future__ import annotations
-from typing import Optional, Union
+import time
+from typing import Union
 import random
-
+from typing import Optional
 from jinja2 import Template
 
-from edsl.utilities import random_string
-from edsl.questions.descriptors import QuestionOptionsDescriptor
 from edsl.questions.QuestionBase import QuestionBase
-from edsl.scenarios import Scenario
+from edsl.questions.descriptors import QuestionOptionsDescriptor
 
 
 class QuestionMultipleChoice(QuestionBase):
-    """This question prompts the agent to select one option from a list of options."""
+    """This question prompts the agent to select one option from a list of options.
+
+    https://docs.expectedparrot.com/en/latest/questions.html#questionmultiplechoice-class
+
+    """
 
     question_type = "multiple_choice"
     purpose = "When options are known and limited"
@@ -36,29 +39,79 @@ class QuestionMultipleChoice(QuestionBase):
         self.question_text = question_text
         self.question_options = question_options
 
+    # @property
+    # def question_options(self) -> Union[list[str], list[list], list[float], list[int]]:
+    #     """Return the question options."""
+    #     return self._question_options
+
     ################
     # Answer methods
     ################
     def _validate_answer(
         self, answer: dict[str, Union[str, int]]
     ) -> dict[str, Union[str, int]]:
-        """Validate the answer."""
+        """Validate the answer.
+
+        >>> q = QuestionMultipleChoice.example()
+        >>> q._validate_answer({"answer": 0, "comment": "I like custard"})
+        {'answer': 0, 'comment': 'I like custard'}
+
+        >>> q = QuestionMultipleChoice(question_name="how_feeling", question_text="How are you?", question_options=["Good", "Great", "OK", "Bad"])
+        >>> q._validate_answer({"answer": -1, "comment": "I like custard"})
+        Traceback (most recent call last):
+        ...
+        edsl.exceptions.questions.QuestionAnswerValidationError: Answer code must be a non-negative integer (got -1).
+        """
         self._validate_answer_template_basic(answer)
         self._validate_answer_multiple_choice(answer)
         return answer
 
-    def _translate_answer_code_to_answer(self, answer_code, scenario: Scenario = None):
-        """Translate the answer code to the actual answer."""
+    def _translate_answer_code_to_answer(
+        self, answer_code: int, scenario: Optional["Scenario"] = None
+    ):
+        """Translate the answer code to the actual answer.
+
+        It is used to translate the answer code to the actual answer.
+        The question options might be templates, so they need to be rendered with the scenario.
+
+        >>> q = QuestionMultipleChoice.example()
+        >>> q._translate_answer_code_to_answer(0, {})
+        'Good'
+
+        >>> q = QuestionMultipleChoice(question_name="how_feeling", question_text="How are you?", question_options=["{{emotion[0]}}", "emotion[1]"])
+        >>> q._translate_answer_code_to_answer(0, {"emotion": ["Happy", "Sad"]})
+        'Happy'
+
+        """
+        from edsl.scenarios.Scenario import Scenario
+
         scenario = scenario or Scenario()
-        translated_options = [
-            Template(str(option)).render(scenario) for option in self.question_options
-        ]
+
+        if isinstance(self.question_options, str):
+            # If dynamic options are provided like {{ options }}, render them with the scenario
+            from jinja2 import Environment, meta
+
+            env = Environment()
+            parsed_content = env.parse(self.question_options)
+            question_option_key = list(meta.find_undeclared_variables(parsed_content))[
+                0
+            ]
+            translated_options = scenario.get(question_option_key)
+        else:
+            translated_options = [
+                Template(str(option)).render(scenario)
+                for option in self.question_options
+            ]
+        # print("Translated options:", translated_options)
+        # breakpoint()
         return translated_options[int(answer_code)]
 
     def _simulate_answer(
         self, human_readable: bool = True
     ) -> dict[str, Union[int, str]]:
         """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
         if human_readable:
             answer = random.choice(self.question_options)
         else:
@@ -70,6 +123,7 @@ class QuestionMultipleChoice(QuestionBase):
 
     @property
     def question_html_content(self) -> str:
+        """Return the HTML version of the question."""
         if hasattr(self, "option_labels"):
             option_labels = self.option_labels
         else:
@@ -127,6 +181,8 @@ def main():
     q.to_dict()
     assert q.from_dict(q.to_dict()) == q
 
+
+if __name__ == "__main__":
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/questions/QuestionNumerical.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 import textwrap
 from random import uniform
 from typing import Any, Optional, Union
+
 from edsl.exceptions import QuestionAnswerValidationError
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import NumericalOrNoneDescriptor
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionNumerical(QuestionBase):
@@ -48,12 +47,14 @@ class QuestionNumerical(QuestionBase):
         self._validate_answer_numerical(answer)
         return answer
 
-    def _translate_answer_code_to_answer(self, answer, scenario: Scenario = None):
+    def _translate_answer_code_to_answer(self, answer, scenario: "Scenario" = None):
         """There is no answer code."""
         return answer
 
     def _simulate_answer(self, human_readable: bool = True):
         """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
         return {
             "answer": uniform(self.min_value, self.max_value),
             "comment": random_string(),

edsl/questions/QuestionRank.py

@@ -1,12 +1,10 @@
 from __future__ import annotations
 import random
-import textwrap
 from jinja2 import Template
 from typing import Any, Optional, Union
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.exceptions import QuestionAnswerValidationError
-from edsl.scenarios import Scenario
-from edsl.utilities.utilities import random_string
+
 from edsl.questions.descriptors import (
     QuestionOptionsDescriptor,
     NumSelectionsDescriptor,
@@ -55,6 +53,8 @@ class QuestionRank(QuestionBase):
         self, answer_codes, scenario: Scenario = None
     ) -> list[str]:
         """Translate the answer code to the actual answer."""
+        from edsl.scenarios import Scenario
+
         scenario = scenario or Scenario()
         translated_options = [
             Template(option).render(scenario) for option in self.question_options
@@ -66,6 +66,8 @@ class QuestionRank(QuestionBase):
 
     def _simulate_answer(self, human_readable=True) -> dict[str, Union[int, str]]:
         """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
         if human_readable:
             selected = random.sample(self.question_options, self.num_selections)
         else:

edsl/questions/__init__.py

@@ -10,17 +10,18 @@ from edsl.questions.QuestionBudget import QuestionBudget
 from edsl.questions.QuestionCheckBox import QuestionCheckBox
 from edsl.questions.QuestionExtract import QuestionExtract
 from edsl.questions.QuestionFreeText import QuestionFreeText
+
 from edsl.questions.QuestionFunctional import QuestionFunctional
 from edsl.questions.QuestionList import QuestionList
 from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
 from edsl.questions.QuestionNumerical import QuestionNumerical
 from edsl.questions.QuestionRank import QuestionRank
 
-# Questions derived from core questions
+# # Questions derived from core questions
 from edsl.questions.derived.QuestionLikertFive import QuestionLikertFive
 from edsl.questions.derived.QuestionLinearScale import QuestionLinearScale
 from edsl.questions.derived.QuestionTopK import QuestionTopK
 from edsl.questions.derived.QuestionYesNo import QuestionYesNo
 
-# Compose Questions
-from edsl.questions.compose_questions import compose_questions
+# # Compose Questions
+# from edsl.questions.compose_questions import compose_questions

edsl/questions/descriptors.py

@@ -2,15 +2,13 @@
 
 from abc import ABC, abstractmethod
 import re
-from typing import Any, Callable
+from typing import Any, Callable, List, Optional
 from edsl.exceptions import (
     QuestionCreationValidationError,
     QuestionAnswerValidationError,
 )
 from edsl.questions.settings import Settings
-from edsl.utilities.utilities import is_valid_variable_name
 
-from edsl.prompts import get_classes
 
 ################################
 # Helper functions
@@ -56,6 +54,8 @@ class BaseDescriptor(ABC):
     def __set__(self, instance, value: Any) -> None:
         """Set the value of the attribute."""
         self.validate(value, instance)
+        from edsl.prompts.registry import get_classes
+
         instance.__dict__[self.name] = value
         if self.name == "_instructions":
             instructions = value
@@ -231,6 +231,8 @@ class QuestionNameDescriptor(BaseDescriptor):
 
     def validate(self, value, instance):
         """Validate the value is a valid variable name."""
+        from edsl.utilities.utilities import is_valid_variable_name
+
         if not is_valid_variable_name(value):
             raise QuestionCreationValidationError(
                 f"`question_name` is not a valid variable name (got {value})."
@@ -240,6 +242,16 @@ class QuestionNameDescriptor(BaseDescriptor):
 class QuestionOptionsDescriptor(BaseDescriptor):
     """Validate that `question_options` is a list, does not exceed the min/max lengths, and has unique items."""
 
+    @classmethod
+    def example(cls):
+        class TestQuestion:
+            question_options = QuestionOptionsDescriptor()
+
+            def __init__(self, question_options: List[str]):
+                self.question_options = question_options
+
+        return TestQuestion
+
     def __init__(
         self,
         num_choices: int = None,
@@ -252,7 +264,31 @@ class QuestionOptionsDescriptor(BaseDescriptor):
         self.q_budget = q_budget
 
     def validate(self, value: Any, instance) -> None:
-        """Validate the question options."""
+        """Validate the question options.
+
+        >>> q_class = QuestionOptionsDescriptor.example()
+        >>> _ = q_class(["a", "b", "c"])
+        >>> _ = q_class(["a", "b", "c", "d", "d"])
+        Traceback (most recent call last):
+        ...
+        edsl.exceptions.questions.QuestionCreationValidationError: Question options must be unique (got ['a', 'b', 'c', 'd', 'd']).
+
+        We allow dynamic question options, which are strings of the form '{{ question_options }}'.
+
+        >>> _ = q_class("{{dynamic_options}}")
+        >>> _ = q_class("dynamic_options")
+        Traceback (most recent call last):
+        ...
+        edsl.exceptions.questions.QuestionCreationValidationError: Dynamic question options must be of the form: '{{ question_options }}'.
+        """
+        if isinstance(value, str):
+            # Check if the string is a dynamic question option
+            if "{{" in value and "}}" in value:
+                return None
+            else:
+                raise QuestionCreationValidationError(
+                    "Dynamic question options must be of the form: '{{ question_options }}'."
+                )
         if not isinstance(value, list):
             raise QuestionCreationValidationError(
                 f"Question options must be a list (got {value})."
@@ -337,3 +373,9 @@ class QuestionTextDescriptor(BaseDescriptor):
                 f"WARNING: Question text contains a single-braced substring: If you intended to parameterize the question with a Scenario this should be changed to a double-braced substring, e.g. {{variable}}.\nSee details on constructing Scenarios in the docs: https://docs.expectedparrot.com/en/latest/scenarios.html",
                 UserWarning,
             )
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/questions/question_registry.py

@@ -1,10 +1,10 @@
 """This module provides a factory class for creating question objects."""
 
 import textwrap
-from typing import Union
+from uuid import UUID
+from typing import Any, Optional, Union
+
 
-from edsl.exceptions import QuestionSerializationError
-from edsl.exceptions import QuestionCreationValidationError
 from edsl.questions.QuestionBase import RegisterQuestionsMeta
 
 
@@ -60,46 +60,35 @@ class Question(metaclass=Meta):
         return q.example()
 
     @classmethod
-    def pull(cls, id_or_url: str):
+    def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
         """Pull the object from coop."""
         from edsl.coop import Coop
 
-        c = Coop()
-        if c.url in id_or_url:
-            id = id_or_url.split("/")[-1]
-        else:
-            id = id_or_url
-        from edsl.questions.QuestionBase import QuestionBase
-
-        return c._get_base(QuestionBase, id)
+        coop = Coop()
+        return coop.get(uuid, url, "question")
 
     @classmethod
-    def delete(cls, id_or_url: str):
+    def delete(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
         """Delete the object from coop."""
         from edsl.coop import Coop
 
-        c = Coop()
-        if c.url in id_or_url:
-            id = id_or_url.split("/")[-1]
-        else:
-            id = id_or_url
-        from edsl.questions.QuestionBase import QuestionBase
-
-        return c._delete_base(QuestionBase, id)
+        coop = Coop()
+        return coop.delete(uuid, url)
 
     @classmethod
-    def update(cls, id_or_url: str, visibility: str):
-        """Update the object on coop."""
+    def patch(
+        cls,
+        uuid: Optional[Union[str, UUID]] = None,
+        url: Optional[str] = None,
+        description: Optional[str] = None,
+        value: Optional[Any] = None,
+        visibility: Optional[str] = None,
+    ):
+        """Patch the object on coop."""
         from edsl.coop import Coop
 
-        c = Coop()
-        if c.url in id_or_url:
-            id = id_or_url.split("/")[-1]
-        else:
-            id = id_or_url
-        from edsl.questions.QuestionBase import QuestionBase
-
-        return c._update_base(QuestionBase, id, visibility)
+        coop = Coop()
+        return coop.patch(uuid, url, description, value, visibility)
 
     @classmethod
     def available(cls, show_class_names: bool = False) -> Union[list, dict]:

edsl/questions/settings.py

@@ -8,5 +8,5 @@ class Settings:
     MAX_EXPRESSION_CONSTRAINT_LENGTH = 1000
     MAX_NUM_OPTIONS = 200
     MIN_NUM_OPTIONS = 2
-    MAX_OPTION_LENGTH = 1000
+    MAX_OPTION_LENGTH = 10000
     MAX_QUESTION_LENGTH = 100000

edsl/results/Dataset.py

@@ -78,6 +78,28 @@ class Dataset(UserList, ResultsExportMixin):
 
         return get_values(self.data[0])[0]
 
+    def select(self, *keys):
+        """Return a new dataset with only the selected keys.
+
+        :param keys: The keys to select.
+
+        >>> d = Dataset([{'a.b':[1,2,3,4]}, {'c.d':[5,6,7,8]}])
+        >>> d.select('a.b')
+        Dataset([{'a.b': [1, 2, 3, 4]}])
+
+        >>> d.select('a.b', 'c.d')
+        Dataset([{'a.b': [1, 2, 3, 4]}, {'c.d': [5, 6, 7, 8]}])
+        """
+        if isinstance(keys, str):
+            keys = [keys]
+
+        new_data = []
+        for observation in self.data:
+            observation_key = list(observation.keys())[0]
+            if observation_key in keys:
+                new_data.append(observation)
+        return Dataset(new_data)
+
     def _repr_html_(self) -> str:
         """Return an HTML representation of the dataset."""
         from edsl.utilities.utilities import data_to_html
@@ -223,6 +245,15 @@ class Dataset(UserList, ResultsExportMixin):
 
         return Dataset(new_data)
 
+    @classmethod
+    def example(self):
+        """Return an example dataset.
+
+        >>> Dataset.example()
+        Dataset([{'a': [1, 2, 3, 4]}, {'b': [4, 3, 2, 1]}])
+        """
+        return Dataset([{"a": [1, 2, 3, 4]}, {"b": [4, 3, 2, 1]}])
+
 
 if __name__ == "__main__":
     import doctest