edsl 0.1.28__py3-none-any.whl → 0.1.29__py3-none-any.whl

edsl/questions/QuestionBase.py

@@ -1,8 +1,8 @@
 """This module contains the Question class, which is the base class for all questions in EDSL."""
 
 from __future__ import annotations
+import time
 from abc import ABC, abstractmethod
-from rich.table import Table
 from typing import Any, Type, Optional, List, Callable
 import copy
 
@@ -12,7 +12,7 @@ from edsl.exceptions import (
 )
 from edsl.questions.descriptors import QuestionNameDescriptor, QuestionTextDescriptor
 
-from edsl.prompts.registry import get_classes as prompt_lookup
+
 from edsl.questions.AnswerValidatorMixin import AnswerValidatorMixin
 from edsl.questions.RegisterQuestionsMeta import RegisterQuestionsMeta
 from edsl.Base import PersistenceMixin, RichPrintingMixin
@@ -124,6 +124,8 @@ class QuestionBase(
         :param model: The language model to use. If None, assumes does not matter.
 
         """
+        from edsl.prompts.registry import get_classes as prompt_lookup
+
         applicable_prompts = prompt_lookup(
             component_type="question_instructions",
             question_type=cls.question_type,
@@ -173,15 +175,16 @@ class QuestionBase(
     def add_model_instructions(
         self, *, instructions: str, model: Optional[str] = None
     ) -> None:
-        """Add model-specific instructions for the question.
+        """Add model-specific instructions for the question that override the default instructions.
 
         :param instructions: The instructions to add. This is typically a jinja2 template.
         :param model: The language model for this instruction.
 
         >>> from edsl.questions import QuestionFreeText
         >>> q = QuestionFreeText(question_name = "color", question_text = "What is your favorite color?")
-        >>> q.add_model_instructions(instructions = "Answer in valid JSON like so {'answer': 'comment: <>}", model = "gpt3")
-
+        >>> q.add_model_instructions(instructions = "{{question_text}}. Answer in valid JSON like so {'answer': 'comment: <>}", model = "gpt3")
+        >>> q.get_instructions(model = "gpt3")
+        Prompt(text=\"""{{question_text}}. Answer in valid JSON like so {'answer': 'comment: <>}\""")
         """
         from edsl import Model
 
@@ -201,6 +204,13 @@ class QuestionBase(
         """Get the mathcing question-answering instructions for the question.
 
         :param model: The language model to use.
+
+        >>> from edsl import QuestionFreeText
+        >>> QuestionFreeText.example().get_instructions()
+        Prompt(text=\"""You are being asked the following question: {{question_text}}
+        Return a valid JSON formatted like this:
+        {"answer": "<put free text answer here>"}
+        \""")
         """
         from edsl.prompts.Prompt import Prompt
 
@@ -293,7 +303,16 @@ class QuestionBase(
         print_json(json.dumps(self.to_dict()))
 
     def __call__(self, just_answer=True, model=None, agent=None, **kwargs):
-        """Call the question."""
+        """Call the question.
+
+        >>> from edsl.language_models import LanguageModel
+        >>> m = LanguageModel.example(canned_response = "Yo, what's up?", test_model = True)
+        >>> from edsl import QuestionFreeText
+        >>> q = QuestionFreeText(question_name = "color", question_text = "What is your favorite color?")
+        >>> q(model = m)
+        "Yo, what's up?"
+
+        """
         survey = self.to_survey()
         results = survey(model=model, agent=agent, **kwargs)
         if just_answer:
@@ -304,7 +323,6 @@ class QuestionBase(
     async def run_async(self, just_answer=True, model=None, agent=None, **kwargs):
         """Call the question."""
         survey = self.to_survey()
-        ## asyncio.run(survey.async_call());
         results = await survey.run_async(model=model, agent=agent, **kwargs)
         if just_answer:
             return results.select(f"answer.{self.question_name}").first()
@@ -383,29 +401,34 @@ class QuestionBase(
         s = Survey([self, other])
         return s
 
-    def to_survey(self):
+    def to_survey(self) -> "Survey":
         """Turn a single question into a survey."""
         from edsl.surveys.Survey import Survey
 
         s = Survey([self])
         return s
 
-    def run(self, *args, **kwargs):
+    def run(self, *args, **kwargs) -> "Results":
         """Turn a single question into a survey and run it."""
         from edsl.surveys.Survey import Survey
 
         s = self.to_survey()
         return s.run(*args, **kwargs)
 
-    def by(self, *args):
-        """Turn a single question into a survey and run it."""
+    def by(self, *args) -> "Jobs":
+        """Turn a single question into a survey and then a Job."""
         from edsl.surveys.Survey import Survey
 
         s = Survey([self])
         return s.by(*args)
 
-    def human_readable(self):
-        """Print the question in a human readable format."""
+    def human_readable(self) -> str:
+        """Print the question in a human readable format.
+
+        >>> from edsl.questions import QuestionFreeText
+        >>> QuestionFreeText.example().human_readable()
+        'Question Type: free_text\\nQuestion: How are you?'
+        """
         lines = []
         lines.append(f"Question Type: {self.question_type}")
         lines.append(f"Question: {self.question_text}")
@@ -475,6 +498,8 @@ class QuestionBase(
 
     def rich_print(self):
         """Print the question in a rich format."""
+        from rich.table import Table
+
         table = Table(show_header=True, header_style="bold magenta")
         table.add_column("Question Name", style="dim")
         table.add_column("Question Type")

edsl/questions/QuestionBudget.py

@@ -1,11 +1,8 @@
 from __future__ import annotations
 import random
-import textwrap
 from typing import Any, Optional, Union
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import IntegerDescriptor, QuestionOptionsDescriptor
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionBudget(QuestionBase):
@@ -46,7 +43,7 @@ class QuestionBudget(QuestionBase):
         return answer
 
     def _translate_answer_code_to_answer(
-        self, answer_codes: dict[str, int], scenario: Scenario = None
+        self, answer_codes: dict[str, int], scenario: "Scenario" = None
     ):
         """
         Translate the answer codes to the actual answers.
@@ -63,6 +60,8 @@ class QuestionBudget(QuestionBase):
 
     def _simulate_answer(self, human_readable=True):
         """Simulate a valid answer for debugging purposes (what the validator expects)."""
+        from edsl.utilities.utilities import random_string
+
         if human_readable:
             keys = self.question_options
         else:
@@ -163,8 +162,8 @@ def main():
 
 
 if __name__ == "__main__":
-    q = QuestionBudget.example()
-    results = q.run()
+    # q = QuestionBudget.example()
+    # results = q.run()
 
     import doctest
 

edsl/questions/QuestionCheckBox.py

@@ -9,8 +9,6 @@ from edsl.questions.descriptors import (
     IntegerDescriptor,
     QuestionOptionsDescriptor,
 )
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionCheckBox(QuestionBase):
@@ -55,13 +53,17 @@ class QuestionCheckBox(QuestionBase):
         self._validate_answer_checkbox(answer)
         return answer
 
-    def _translate_answer_code_to_answer(self, answer_codes, scenario: Scenario = None):
+    def _translate_answer_code_to_answer(
+        self, answer_codes, scenario: "Scenario" = None
+    ):
         """
         Translate the answer code to the actual answer.
 
         For example, for question options ["a", "b", "c"],the answer codes are 0, 1, and 2.
         The LLM will respond with [0,1] and this code will translate it to ["a","b"].
         """
+        from edsl.scenarios.Scenario import Scenario
+
         scenario = scenario or Scenario()
         translated_options = [
             Template(option).render(scenario) for option in self.question_options
@@ -73,6 +75,8 @@ class QuestionCheckBox(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
+
         min_selections = self.min_selections or 1
         max_selections = self.max_selections or len(self.question_options)
         num_selections = random.randint(min_selections, max_selections)

edsl/questions/QuestionExtract.py

@@ -2,8 +2,6 @@ from __future__ import annotations
 from typing import Any
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import AnswerTemplateDescriptor
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionExtract(QuestionBase):
@@ -44,12 +42,14 @@ class QuestionExtract(QuestionBase):
         self._validate_answer_extract(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):
         """Return the answer in a human-readable format."""
         return answer
 
     def _simulate_answer(self, human_readable: bool = True) -> dict[str, str]:
         """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
         return {
             "answer": {key: random_string() for key in self.answer_template.keys()},
             "comment": random_string(),
@@ -106,6 +106,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/QuestionFreeText.py

@@ -2,8 +2,6 @@ from __future__ import annotations
 import textwrap
 from typing import Any, Optional
 from edsl.questions.QuestionBase import QuestionBase
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionFreeText(QuestionBase):
@@ -43,12 +41,14 @@ class QuestionFreeText(QuestionBase):
         self._validate_answer_key_value(answer, "answer", str)
         return answer
 
-    def _translate_answer_code_to_answer(self, answer, scenario: Scenario = None):
+    def _translate_answer_code_to_answer(self, answer, scenario: "Scenario" = None):
         """Do nothing, because the answer is already in a human-readable format."""
         return answer
 
     def _simulate_answer(self, human_readable: bool = True) -> dict[str, str]:
         """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
         return {"answer": random_string()}
 
     @property

edsl/questions/QuestionFunctional.py

@@ -1,10 +1,7 @@
 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
 

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,13 +1,12 @@
 from __future__ import annotations
-from typing import Optional, Union
+import time
+from typing import Union
 import random
 
 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):
@@ -15,9 +14,9 @@ class QuestionMultipleChoice(QuestionBase):
 
     question_type = "multiple_choice"
     purpose = "When options are known and limited"
-    question_options: Union[
-        list[str], list[list], list[float], list[int]
-    ] = QuestionOptionsDescriptor()
+    question_options: Union[list[str], list[list], list[float], list[int]] = (
+        QuestionOptionsDescriptor()
+    )
 
     def __init__(
         self,
@@ -47,8 +46,12 @@ class QuestionMultipleChoice(QuestionBase):
         self._validate_answer_multiple_choice(answer)
         return answer
 
-    def _translate_answer_code_to_answer(self, answer_code, scenario: Scenario = None):
+    def _translate_answer_code_to_answer(
+        self, answer_code, scenario: "Scenario" = None
+    ):
         """Translate the answer code to the actual answer."""
+        from edsl.scenarios.Scenario import Scenario
+
         scenario = scenario or Scenario()
         translated_options = [
             Template(str(option)).render(scenario) for option in self.question_options
@@ -59,6 +62,8 @@ class QuestionMultipleChoice(QuestionBase):
         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 +75,7 @@ class QuestionMultipleChoice(QuestionBase):
 
     @property
     def question_html_content(self) -> str:
+
         if hasattr(self, "option_labels"):
             option_labels = self.option_labels
         else:
@@ -127,6 +133,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

@@ -8,9 +8,7 @@ from edsl.exceptions import (
     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})."

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