edsl 0.1.38.dev1__py3-none-any.whl → 0.1.38.dev2__py3-none-any.whl

edsl/questions/QuestionBasePromptsMixin.py

@@ -126,7 +126,6 @@ class QuestionBasePromptsMixin:
 
     @classmethod
     def default_question_presentation(cls):
-        # template_text = cls._read_template("question_presentation.jinja")
         template_text = template_manager.get_template(
             cls.question_type, "question_presentation.jinja"
         )
@@ -142,22 +141,6 @@ class QuestionBasePromptsMixin:
     def answering_instructions(self, value) -> None:
         self._answering_instructions = value
 
-    # @classmethod
-    # def default_answering_instructions(cls) -> str:
-    #     with resources.open_text(
-    #         f"edsl.questions.templates.{cls.question_type}",
-    #         "answering_instructions.jinja",
-    #     ) as file:
-    #         return Prompt(text=file.read())
-
-    # @classmethod
-    # def default_question_presentation(cls):
-    #     with resources.open_text(
-    #         f"edsl.questions.templates.{cls.question_type}",
-    #         "question_presentation.jinja",
-    #     ) as file:
-    #         return Prompt(text=file.read())
-
     @property
     def question_presentation(self):
         if self._question_presentation is None:

edsl/questions/QuestionFunctional.py

@@ -108,15 +108,22 @@ class QuestionFunctional(QuestionBase):
     def question_html_content(self) -> str:
         return "NA for QuestionFunctional"
 
-    @add_edsl_version
-    def to_dict(self):
-        return {
+    # @add_edsl_version
+    def to_dict(self, add_edsl_version=True):
+        d = {
             "question_name": self.question_name,
             "function_source_code": self.function_source_code,
             "question_type": "functional",
             "requires_loop": self.requires_loop,
             "function_name": self.function_name,
         }
+        if add_edsl_version:
+            from edsl import __version__
+
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = self.__class__.__name__
+
+        return d
 
     @classmethod
     def example(cls):

edsl/questions/derived/QuestionTopK.py

@@ -21,6 +21,7 @@ class QuestionTopK(QuestionCheckBox):
         question_presentation: Optional[str] = None,
         answering_instructions: Optional[str] = None,
         include_comment: Optional[bool] = True,
+        use_code: Optional[bool] = True,
     ):
         """Initialize the question.
 
@@ -39,6 +40,7 @@ class QuestionTopK(QuestionCheckBox):
             question_presentation=question_presentation,
             answering_instructions=answering_instructions,
             include_comment=include_comment,
+            use_code=use_code,
         )
         if min_selections != max_selections:
             raise QuestionCreationValidationError(

edsl/results/Result.py

@@ -156,15 +156,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
@@ -324,14 +324,24 @@ class Result(Base, UserDict):
     ###############
     # Serialization
     ###############
-    def _to_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the Result object."""
-        d = {}
-        for key, value in self.items():
+    def to_dict(self, add_edsl_version=True) -> dict[str, Any]:
+        """Return a dictionary representation of the Result object.
+
+        >>> r = Result.example()
+        >>> r.to_dict()['scenario']
+        {'period': 'morning', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
+        """
+
+        def convert_value(value, add_edsl_version=True):
             if hasattr(value, "to_dict"):
-                d[key] = value.to_dict()
+                return value.to_dict(add_edsl_version=add_edsl_version)
             else:
-                d[key] = value
+                return value
+
+        d = {}
+        for key, value in self.items():
+            d[key] = convert_value(value, add_edsl_version=add_edsl_version)
+
             if key == "prompt":
                 new_prompt_dict = {}
                 for prompt_name, prompt_obj in value.items():
@@ -341,23 +351,19 @@ class Result(Base, UserDict):
                         else prompt_obj.to_dict()
                     )
                 d[key] = new_prompt_dict
-        return d
+        if add_edsl_version:
+            from edsl import __version__
 
-    @add_edsl_version
-    def to_dict(self) -> dict[str, Any]:
-        """Return a dictionary representation of the Result object.
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "Result"
 
-        >>> r = Result.example()
-        >>> r.to_dict()['scenario']
-        {'period': 'morning', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
-        """
-        return self._to_dict()
+        return d
 
     def __hash__(self):
         """Return a hash of the Result object."""
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
 
     @classmethod
     @remove_edsl_version

edsl/results/Results.py

@@ -261,25 +261,39 @@ class Results(UserList, Mixins, Base):
         return f"Results(data = {reprlib.repr(self.data)}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
 
     def _repr_html_(self) -> str:
-        from IPython.display import HTML
+        # from IPython.display import HTML
 
-        json_str = json.dumps(self.to_dict()["data"], indent=4)
+        json_str = json.dumps(self.to_dict(add_edsl_version=False)["data"], indent=4)
         return f"<pre>{json_str}</pre>"
 
-    def _to_dict(self, sort=False):
+    def to_dict(self, sort=False, add_edsl_version=False) -> dict[str, Any]:
         from edsl.data.Cache import Cache
 
         if sort:
             data = sorted([result for result in self.data], key=lambda x: hash(x))
         else:
             data = [result for result in self.data]
-        return {
-            "data": [result.to_dict() for result in data],
-            "survey": self.survey.to_dict(),
+
+        d = {
+            "data": [
+                result.to_dict(add_edsl_version=add_edsl_version) for result in data
+            ],
+            "survey": self.survey.to_dict(add_edsl_version=add_edsl_version),
             "created_columns": self.created_columns,
-            "cache": Cache() if not hasattr(self, "cache") else self.cache.to_dict(),
+            "cache": (
+                Cache()
+                if not hasattr(self, "cache")
+                else self.cache.to_dict(add_edsl_version=add_edsl_version)
+            ),
             "task_history": self.task_history.to_dict(),
         }
+        if add_edsl_version:
+            from edsl import __version__
+
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "Results"
+
+        return d
 
     def compare(self, other_results):
         """
@@ -302,22 +316,8 @@ class Results(UserList, Mixins, Base):
     def has_unfixed_exceptions(self):
         return self.task_history.has_unfixed_exceptions
 
-    @add_edsl_version
-    def to_dict(self) -> dict[str, Any]:
-        """Convert the Results object to a dictionary.
-
-        The dictionary can be quite large, as it includes all of the data in the Results object.
-
-        Example: Illustrating just the keys of the dictionary.
-
-        >>> r = Results.example()
-        >>> r.to_dict().keys()
-        dict_keys(['data', 'survey', 'created_columns', 'cache', 'task_history', 'edsl_version', 'edsl_class_name'])
-        """
-        return self._to_dict()
-
     def __hash__(self) -> int:
-        return dict_hash(self._to_dict(sort=True))
+        return dict_hash(self.to_dict(sort=True, add_edsl_version=False))
 
     @property
     def hashes(self) -> set:

edsl/scenarios/Scenario.py

@@ -137,7 +137,7 @@ class Scenario(Base, UserDict, ScenarioHtmlMixin):
                 new_scenario[key] = value
         return new_scenario
 
-    def _to_dict(self) -> dict:
+    def to_dict(self, add_edsl_version=True) -> dict:
         """Convert a scenario to a dictionary.
 
         Example:
@@ -145,26 +145,24 @@ class Scenario(Base, UserDict, ScenarioHtmlMixin):
         >>> s = Scenario({"food": "wood chips"})
         >>> s.to_dict()
         {'food': 'wood chips', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
+
+        >>> s.to_dict(add_edsl_version = False)
+        {'food': 'wood chips'}
+
         """
         from edsl.scenarios.FileStore import FileStore
 
         d = self.data.copy()
         for key, value in d.items():
             if isinstance(value, FileStore):
-                d[key] = value.to_dict()
-        return d
+                d[key] = value.to_dict(add_edsl_version=add_edsl_version)
+        if add_edsl_version:
+            from edsl import __version__
 
-    @add_edsl_version
-    def to_dict(self) -> dict:
-        """Convert a scenario to a dictionary.
-
-        Example:
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "Scenario"
 
-        >>> s = Scenario({"food": "wood chips"})
-        >>> s.to_dict()
-        {'food': 'wood chips', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
-        """
-        return self._to_dict()
+        return d
 
     def __hash__(self) -> int:
         """
@@ -178,7 +176,7 @@ class Scenario(Base, UserDict, ScenarioHtmlMixin):
         """
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
 
     def print(self):
         from rich import print_json

edsl/scenarios/ScenarioList.py

@@ -20,7 +20,7 @@ from edsl.scenarios.Scenario import Scenario
 from edsl.scenarios.ScenarioListPdfMixin import ScenarioListPdfMixin
 from edsl.scenarios.ScenarioListExportMixin import ScenarioListExportMixin
 
-from edsl.conjure.naming_utilities import sanitize_string
+from edsl.utilities.naming_utilities import sanitize_string
 from edsl.utilities.utilities import is_valid_variable_name
 
 
@@ -239,7 +239,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         """
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict(sort=True))
+        return dict_hash(self.to_dict(sort=True, add_edsl_version=False))
 
     def __repr__(self):
         return f"ScenarioList({self.data})"
@@ -958,24 +958,24 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
 
         return cls(observations)
 
-    def _to_dict(self, sort=False) -> dict:
+    def to_dict(self, sort=False, add_edsl_version=True) -> dict:
+        """
+        >>> s = ScenarioList([Scenario({'food': 'wood chips'}), Scenario({'food': 'wood-fired pizza'})])
+        >>> s.to_dict()
+        {'scenarios': [{'food': 'wood chips', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}, {'food': 'wood-fired pizza', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}], 'edsl_version': '...', 'edsl_class_name': 'ScenarioList'}
+
+        """
         if sort:
             data = sorted(self, key=lambda x: hash(x))
         else:
             data = self
-        return {"scenarios": [s._to_dict() for s in data]}
-
-    @add_edsl_version
-    def to_dict(self) -> dict[str, Any]:
-        """Return the `ScenarioList` as a dictionary.
+        d = {"scenarios": [s.to_dict(add_edsl_version=add_edsl_version) for s in data]}
+        if add_edsl_version:
+            from edsl import __version__
 
-        Example:
-
-        >>> s = ScenarioList([Scenario({'food': 'wood chips'}), Scenario({'food': 'wood-fired pizza'})])
-        >>> s.to_dict()
-        {'scenarios': [{'food': 'wood chips', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}, {'food': 'wood-fired pizza', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}], 'edsl_version': '...', 'edsl_class_name': 'ScenarioList'}
-        """
-        return {"scenarios": [s.to_dict() for s in self]}
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = self.__class__.__name__
+        return d
 
     @classmethod
     def gen(cls, scenario_dicts_list: List[dict]) -> ScenarioList:
@@ -1061,7 +1061,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         elif isinstance(key, int):
             return super().__getitem__(key)
         else:
-            return self._to_dict()[key]
+            return self.to_dict(add_edsl_version=False)[key]
 
     def to_agent_list(self):
         """Convert the ScenarioList to an AgentList.

edsl/surveys/MemoryPlan.py

@@ -143,7 +143,7 @@ class MemoryPlan(UserDict):
         for question in prior_questions:
             self.add_single_memory(focal_question, question)
 
-    def to_dict(self) -> dict:
+    def to_dict(self, add_edsl_version=True) -> dict:
         """Serialize the memory plan to a dictionary.
 
         >>> mp = MemoryPlan.example()

edsl/surveys/Rule.py

@@ -148,10 +148,7 @@ class Rule:
     def _checks(self):
         pass
 
-    # def _to_dict(self):
-
-    # @add_edsl_version
-    def to_dict(self):
+    def to_dict(self, add_edsl_version=True):
         """Convert the rule to a dictionary for serialization.
 
         >>> r = Rule.example()
@@ -166,7 +163,6 @@ class Rule:
             "question_name_to_index": self.question_name_to_index,
             "before_rule": self.before_rule,
         }
-        # return self._to_dict()
 
     @classmethod
     @remove_edsl_version

edsl/surveys/RuleCollection.py

@@ -46,7 +46,7 @@ class RuleCollection(UserList):
         """
         return f"RuleCollection(rules={self.data}, num_questions={self.num_questions})"
 
-    def to_dict(self):
+    def to_dict(self, add_edsl_version=True):
         """Create a dictionary representation of the RuleCollection object."""
         return {
             "rules": [rule.to_dict() for rule in self],

edsl/surveys/Survey.py

@@ -445,35 +445,27 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         """Return a hash of the question."""
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
 
-    def _to_dict(self) -> dict[str, Any]:
+    def to_dict(self, add_edsl_version=True) -> dict[str, Any]:
         """Serialize the Survey object to a dictionary.
 
         >>> s = Survey.example()
-        >>> s._to_dict().keys()
+        >>> s.to_dict(add_edsl_version = False).keys()
         dict_keys(['questions', 'memory_plan', 'rule_collection', 'question_groups'])
         """
         return {
             "questions": [
-                q._to_dict() for q in self.recombined_questions_and_instructions()
+                q.to_dict(add_edsl_version=add_edsl_version)
+                for q in self.recombined_questions_and_instructions()
             ],
-            "memory_plan": self.memory_plan.to_dict(),
-            "rule_collection": self.rule_collection.to_dict(),
+            "memory_plan": self.memory_plan.to_dict(add_edsl_version=add_edsl_version),
+            "rule_collection": self.rule_collection.to_dict(
+                add_edsl_version=add_edsl_version
+            ),
             "question_groups": self.question_groups,
         }
 
-    @add_edsl_version
-    def to_dict(self) -> dict[str, Any]:
-        """Serialize the Survey object to a dictionary.
-
-        >>> s = Survey.example()
-        >>> s.to_dict().keys()
-        dict_keys(['questions', 'memory_plan', 'rule_collection', 'question_groups', 'edsl_version', 'edsl_class_name'])
-
-        """
-        return self._to_dict()
-
     @classmethod
     @remove_edsl_version
     def from_dict(cls, data: dict) -> Survey:

edsl/surveys/instructions/ChangeInstruction.py

@@ -24,22 +24,24 @@ class ChangeInstruction:
     def __str__(self):
         return self.text
 
-    def _to_dict(self):
-        return {
+    def to_dict(self, add_edsl_version=True):
+        d = {
             "keep": self.keep,
             "drop": self.drop,
-            "edsl_class_name": "ChangeInstruction",
         }
+        if add_edsl_version:
+            from edsl import __version__
 
-    @add_edsl_version
-    def to_dict(self):
-        return self._to_dict()
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "ChangeInstruction"
+
+        return d
 
     def __hash__(self) -> int:
         """Return a hash of the question."""
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
 
     @classmethod
     @remove_edsl_version

edsl/surveys/instructions/Instruction.py

@@ -18,28 +18,30 @@ class Instruction:
     def __repr__(self):
         return """Instruction(name="{}", text="{}")""".format(self.name, self.text)
 
-    def _to_dict(self):
-        return {
+    def to_dict(self, add_edsl_version=True):
+        d = {
             "name": self.name,
             "text": self.text,
             "edsl_class_name": "Instruction",
             "preamble": self.preamble,
         }
+        if add_edsl_version:
+            from edsl import __version__
+
+            d["edsl_version"] = __version__
+            d["edsl_class_name"] = "Instruction"
+        return d
 
     def add_question(self, question) -> "Survey":
         from edsl import Survey
 
         return Survey([self, question])
 
-    @add_edsl_version
-    def to_dict(self):
-        return self._to_dict()
-
     def __hash__(self) -> int:
         """Return a hash of the question."""
         from edsl.utilities.utilities import dict_hash
 
-        return dict_hash(self._to_dict())
+        return dict_hash(self.to_dict(add_edsl_version=False))
 
     @classmethod
     @remove_edsl_version

edsl/{conjure → utilities}/naming_utilities.py

@@ -257,7 +257,7 @@ def sanitize_string(input_string, max_length=35):
 #         print()
 
 if __name__ == "__main__":
-    from edsl.conjure.InputData import InputDataABC
+    # from edsl.conjure.InputData import InputDataABC
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)

{edsl-0.1.38.dev1.dist-info → edsl-0.1.38.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.38.dev1
+Version: 0.1.38.dev2
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT