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

edsl/questions/QuestionExtract.py

@@ -2,6 +2,8 @@ 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):
@@ -42,14 +44,12 @@ 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,8 +106,6 @@ 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,6 +2,8 @@ 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):
@@ -41,14 +43,12 @@ 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,7 +1,10 @@
 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,6 +5,9 @@ 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."""
@@ -39,15 +42,13 @@ 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,12 +1,13 @@
 from __future__ import annotations
-import time
-from typing import Union
+from typing import Optional, Union
 import random
 
 from jinja2 import Template
 
-from edsl.questions.QuestionBase import QuestionBase
+from edsl.utilities import random_string
 from edsl.questions.descriptors import QuestionOptionsDescriptor
+from edsl.questions.QuestionBase import QuestionBase
+from edsl.scenarios import Scenario
 
 
 class QuestionMultipleChoice(QuestionBase):
@@ -14,9 +15,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,
@@ -46,12 +47,8 @@ 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
@@ -62,8 +59,6 @@ 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:
@@ -75,7 +70,6 @@ class QuestionMultipleChoice(QuestionBase):
 
     @property
     def question_html_content(self) -> str:
-
         if hasattr(self, "option_labels"):
             option_labels = self.option_labels
         else:
@@ -133,8 +127,6 @@ 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,10 +2,11 @@ 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):
@@ -47,14 +48,12 @@ 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,10 +1,12 @@
 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,
@@ -53,8 +55,6 @@ 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,8 +66,6 @@ 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,18 +10,17 @@ 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,7 +8,9 @@ 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
@@ -54,8 +56,6 @@ 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,8 +231,6 @@ 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 uuid import UUID
-from typing import Any, Optional, Union
-
+from typing import Union
 
+from edsl.exceptions import QuestionSerializationError
+from edsl.exceptions import QuestionCreationValidationError
 from edsl.questions.QuestionBase import RegisterQuestionsMeta
 
 
@@ -60,35 +60,46 @@ class Question(metaclass=Meta):
         return q.example()
 
     @classmethod
-    def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
+    def pull(cls, id_or_url: str):
         """Pull the object from coop."""
         from edsl.coop import Coop
 
-        coop = Coop()
-        return coop.get(uuid, url, "question")
+        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)
 
     @classmethod
-    def delete(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
+    def delete(cls, id_or_url: str):
         """Delete the object from coop."""
         from edsl.coop import Coop
 
-        coop = Coop()
-        return coop.delete(uuid, url)
+        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)
 
     @classmethod
-    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."""
+    def update(cls, id_or_url: str, visibility: str):
+        """Update the object on coop."""
         from edsl.coop import Coop
 
-        coop = Coop()
-        return coop.patch(uuid, url, description, value, visibility)
+        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)
 
     @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 = 10000
+    MAX_OPTION_LENGTH = 1000
     MAX_QUESTION_LENGTH = 100000

edsl/results/Dataset.py

@@ -78,28 +78,6 @@ 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
@@ -245,15 +223,6 @@ 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

edsl/results/Result.py

@@ -3,7 +3,16 @@ from __future__ import annotations
 from collections import UserDict
 from typing import Any, Type, Callable, Optional
 from collections import UserDict
+
+from rich.table import Table
+
+from IPython.display import display
+
+from edsl.agents import Agent
+from edsl.language_models import LanguageModel
+from edsl.scenarios import Scenario
 from edsl.Base import Base
+from edsl.prompts import Prompt
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
@@ -12,8 +21,6 @@ class PromptDict(UserDict):
 
     def rich_print(self):
         """Display an object as a table."""
-        from rich.table import Table
-
         table = Table(title="")
         table.add_column("Attribute", style="bold")
         table.add_column("Value")
@@ -64,9 +71,9 @@ class Result(Base, UserDict):
 
     def __init__(
         self,
-        agent: "Agent",
-        scenario: "Scenario",
-        model: Type["LanguageModel"],
+        agent: Agent,
+        scenario: Scenario,
+        model: Type[LanguageModel],
         iteration: int,
         answer: str,
         prompt: dict[str, str] = None,
@@ -145,15 +152,15 @@ class Result(Base, UserDict):
             if key in self.question_to_attributes:
                 # You might be tempted to just use the naked key
                 # but this is a bad idea because it pollutes the namespace
-                question_text_dict[key + "_question_text"] = (
-                    self.question_to_attributes[key]["question_text"]
-                )
-                question_options_dict[key + "_question_options"] = (
-                    self.question_to_attributes[key]["question_options"]
-                )
-                question_type_dict[key + "_question_type"] = (
-                    self.question_to_attributes[key]["question_type"]
-                )
+                question_text_dict[
+                    key + "_question_text"
+                ] = self.question_to_attributes[key]["question_text"]
+                question_options_dict[
+                    key + "_question_options"
+                ] = self.question_to_attributes[key]["question_options"]
+                question_type_dict[
+                    key + "_question_type"
+                ] = self.question_to_attributes[key]["question_type"]
 
         return {
             "agent": self.agent.traits
@@ -271,12 +278,6 @@ class Result(Base, UserDict):
     @remove_edsl_version
     def from_dict(self, json_dict: dict) -> Result:
         """Return a Result object from a dictionary representation."""
-
-        from edsl import Agent
-        from edsl import Scenario
-        from edsl.language_models.LanguageModel import LanguageModel
-        from edsl.prompts.Prompt import Prompt
-
         prompt_data = json_dict.get("prompt", {})
         prompt_d = {}
         for prompt_name, prompt_obj in prompt_data.items():
@@ -300,7 +301,6 @@ class Result(Base, UserDict):
         """Display an object as a table."""
         # from edsl.utilities import print_dict_with_rich
         from rich import print
-        from rich.table import Table
 
         table = Table(title="Result")
         table.add_column("Attribute", style="bold")
@@ -325,7 +325,7 @@ class Result(Base, UserDict):
     @classmethod
     def example(cls):
         """Return an example Result object."""
-        from edsl.results.Results import Results
+        from edsl.results import Results
 
         return Results.example()[0]
 
@@ -350,7 +350,59 @@ class Result(Base, UserDict):
         return scoring_function(**params)
 
 
+def main():
+    """Run the main function."""
+    from edsl.results.Result import Result
+    import json
+
+    print("Being imported")
+    json_string = """
+    {
+        "agent": {
+            "traits": {
+                "status": "Unhappy"
+            }
+        },
+        "scenario": {
+            "period": "morning"
+        },
+        "model": {
+            "model": "gpt-3.5-turbo",
+            "parameters": {
+                "temperature": 0.5,
+                "max_tokens": 1000,
+                "top_p": 1,
+                "frequency_penalty": 0,
+                "presence_penalty": 0,
+                "use_cache": true
+            }
+        },
+        "iteration": 0,
+        "answer": {
+            "how_feeling": "Bad"
+        }, 
+        "prompt": {"how_feeling_user_prompt": "How are you feeling today?", "how_feeling_system_prompt": "Answer the question"}
+    }
+    """
+
+    result = Result.from_dict(json.loads(json_string))
+
+    result.sub_dicts
+    assert result.combined_dict["how_feeling"] == "Bad"
+
+    result.combined_dict
+    assert result.get_value("answer", "how_feeling") == "Bad"
+
+    result.key_to_data_type
+    print(result)
+
+    assert result == result.copy()
+
+    result.to_dict()
+
+
 if __name__ == "__main__":
+    # print(Result.example())
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)