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

edsl/scenarios/ScenarioList.py

@@ -5,22 +5,25 @@ import csv
 import random
 from collections import UserList, Counter
 from collections.abc import Iterable
+
 from typing import Any, Optional, Union, List
 
+from rich.table import Table
 from simpleeval import EvalWithCompoundTypes
 
+from edsl.scenarios.Scenario import Scenario
 from edsl.Base import Base
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
-from edsl.scenarios.Scenario import Scenario
 from edsl.scenarios.ScenarioListPdfMixin import ScenarioListPdfMixin
-from edsl.scenarios.ScenarioListExportMixin import ScenarioListExportMixin
 
+from edsl.utilities.interface import print_scenario_list
 
-class ScenarioListMixin(ScenarioListPdfMixin, ScenarioListExportMixin):
-    pass
+from edsl.utilities import is_valid_variable_name
 
+from edsl.results.ResultsExportMixin import ResultsExportMixin
 
-class ScenarioList(Base, UserList, ScenarioListMixin):
+
+class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
     """Class for creating a list of scenarios to be used in a survey."""
 
     def __init__(self, data: Optional[list] = None):
@@ -116,7 +119,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
 
         return ScenarioList(random.sample(self.data, n))
 
-    def expand(self, expand_field: str, number_field=False) -> ScenarioList:
+    def expand(self, expand_field: str, number_field = False) -> ScenarioList:
         """Expand the ScenarioList by a field.
 
         Example:
@@ -134,7 +137,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
                 new_scenario = scenario.copy()
                 new_scenario[expand_field] = value
                 if number_field:
-                    new_scenario[expand_field + "_number"] = index + 1
+                    new_scenario[expand_field + '_number'] = index + 1
                 new_scenarios.append(new_scenario)
         return ScenarioList(new_scenarios)
 
@@ -154,8 +157,6 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
             )
         raw_var_name, expression = new_var_string.split("=", 1)
         var_name = raw_var_name.strip()
-        from edsl.utilities.utilities import is_valid_variable_name
-
         if not is_valid_variable_name(var_name):
             raise Exception(f"{var_name} is not a valid variable name.")
 
@@ -191,7 +192,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
 
         def get_sort_key(scenario: Any) -> tuple:
             return tuple(scenario[field] for field in fields)
-
+        
         return ScenarioList(sorted(self, key=get_sort_key, reverse=reverse))
 
     def filter(self, expression: str) -> ScenarioList:
@@ -342,20 +343,6 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         """
         return cls([Scenario(row) for row in df.to_dict(orient="records")])
 
-    def to_key_value(self, field, value=None) -> Union[dict, set]:
-        """Return the set of values in the field.
-
-        Example:
-
-        >>> s = ScenarioList([Scenario({'name': 'Alice'}), Scenario({'name': 'Bob'})])
-        >>> s.to_key_value('name') == {'Alice', 'Bob'}
-        True
-        """
-        if value is None:
-            return {scenario[field] for scenario in self}
-        else:
-            return {scenario[field]: scenario[value] for scenario in self}
-
     @classmethod
     def from_csv(cls, filename: str) -> ScenarioList:
         """Create a ScenarioList from a CSV file.
@@ -375,8 +362,6 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         >>> scenario_list[1]['age']
         '25'
         """
-        from edsl.scenarios.Scenario import Scenario
-
         observations = []
         with open(filename, "r") as f:
             reader = csv.reader(f)
@@ -414,16 +399,12 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         ScenarioList([Scenario({'name': 'Alice'}), Scenario({'name': 'Bob'})])
 
         """
-        from edsl.scenarios.Scenario import Scenario
-
         return cls([Scenario(s) for s in scenario_dicts_list])
 
     @classmethod
     @remove_edsl_version
     def from_dict(cls, data) -> ScenarioList:
         """Create a `ScenarioList` from a dictionary."""
-        from edsl.scenarios.Scenario import Scenario
-
         return cls([Scenario.from_dict(s) for s in data["scenarios"]])
 
     def code(self) -> str:
@@ -448,8 +429,6 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
 
     def rich_print(self) -> None:
         """Display an object as a table."""
-        from rich.table import Table
-
         table = Table(title="ScenarioList")
         table.add_column("Index", style="bold")
         table.add_column("Scenario")
@@ -464,8 +443,6 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         pretty_labels: Optional[dict] = None,
         filename: str = None,
     ):
-        from edsl.utilities.interface import print_scenario_list
-
         print_scenario_list(self[:max_rows])
 
     def __getitem__(self, key: Union[int, slice]) -> Any:

edsl/scenarios/ScenarioListPdfMixin.py

@@ -2,7 +2,7 @@ import fitz  # PyMuPDF
 import os
 import subprocess
 
-# from edsl import Scenario
+from edsl import Scenario
 
 
 class ScenarioListPdfMixin:
@@ -22,7 +22,6 @@ class ScenarioListPdfMixin:
         """
         import tempfile
         from pdf2image import convert_from_path
-        from edsl.scenarios import Scenario
 
         with tempfile.TemporaryDirectory() as output_folder:
             # Convert PDF to images

edsl/scenarios/__init__.py

@@ -1,2 +1 @@
 from edsl.scenarios.Scenario import Scenario
-from edsl.scenarios.ScenarioList import ScenarioList

edsl/study/ObjectEntry.py

@@ -1,8 +1,5 @@
 import time
-import webbrowser
-from typing import Any, Dict, Optional, Type
-from edsl import QuestionBase
-from edsl.Base import RegisterSubclassesMeta
+from typing import Optional, Dict, Any, Type
 
 
 class ObjectEntry:
@@ -15,16 +12,6 @@ class ObjectEntry:
         created_at: Optional[float] = None,
         edsl_class_name: Optional[str] = None,
     ):
-        """
-        Initialize an ObjectEntry instance.
-
-        :param variable_name: The name of the variable.
-        :param object: The object being wrapped.
-        :param description: A description of the object.
-        :param coop_info: Optional Coop information dictionary.
-        :param created_at: Optional creation timestamp. Defaults to current time.
-        :param edsl_class_name: Optional EDSL class name. Defaults to object's class name.
-        """
         self.created_at = created_at or time.time()
         self.variable_name = variable_name
         self.object = object
@@ -33,33 +20,22 @@ class ObjectEntry:
         self.coop_info = coop_info
 
     @classmethod
-    def _get_class(cls, object_dict: Dict[str, Any]) -> Type:
-        """
-        Get the class of an object from its dictionary representation.
-
-        :param object_dict: The dictionary representation of the object.
-        :return: The class of the object.
-        """
-        class_name = object_dict["edsl_class_name"]
+    def _get_class(self, obj_dict: Dict[str, Any]) -> Type:
+        "Get the class of an object from its dictionary representation."
+        class_name = obj_dict["edsl_class_name"]
         if class_name == "QuestionBase":
+            from edsl import QuestionBase
+
             return QuestionBase
         else:
+            from edsl.Base import RegisterSubclassesMeta
+
             return RegisterSubclassesMeta._registry[class_name]
 
     def __repr__(self) -> str:
-        """
-        Return a string representation of the ObjectEntry instance.
-
-        :return: A string representation of the ObjectEntry instance.
-        """
         return f"ObjectEntry(variable_name='{self.variable_name}', object={self.object!r}, description='{self.description}', coop_info={self.coop_info}, created_at={self.created_at}, edsl_class_name='{self.edsl_class_name}')"
 
     def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert the ObjectEntry instance to a dictionary.
-
-        :return: A dictionary representation of the ObjectEntry instance.
-        """
         return {
             "created_at": self.created_at,
             "variable_name": self.variable_name,
@@ -71,65 +47,34 @@ class ObjectEntry:
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> "ObjectEntry":
-        """
-        Create an ObjectEntry instance from a dictionary.
-
-        :param d: The dictionary representation of the ObjectEntry instance.
-        :return: An ObjectEntry instance.
-        """
         d["object"] = cls._get_class(d["object"]).from_dict(d["object"])
         return cls(**d)
 
     @property
     def hash(self) -> str:
-        """
-        Compute the hash of the object.
-
-        :return: The hash of the object as a string.
-        """
         return str(hash(self.object))
 
     def add_to_namespace(self) -> None:
-        """
-        Add the object to the global namespace using its variable name.
-        """
         globals()[self.variable_name] = self.object
 
     @property
     def coop_info(self) -> Optional[Dict[str, Any]]:
-        """
-        Get the Coop information for the object.
-
-        :return: The Coop information dictionary, if available.
-        """
         return self._coop_info
 
     @coop_info.setter
     def coop_info(self, coop_info: Optional[Dict[str, Any]]) -> None:
-        """
-        Set the Coop information for the object.
-
-        :param coop_info: The Coop information dictionary.
-        """
         self._coop_info = coop_info
 
     def view_on_coop(self) -> None:
-        """
-        Open the object's Coop URL in a web browser.
-        """
         if self.coop_info is None:
             print("Object not pushed to coop")
             return
-        url = self.coop_info.get("url")
-        webbrowser.open(url)
+        url = self.coop_info["url"]
+        import webbrowser
 
-    def push(self, refresh: Optional[bool] = False) -> Dict[str, Any]:
-        """
-        Push the object to the Coop.
+        webbrowser.open(url)
 
-        :param refresh: Whether to refresh the Coop entry for the object.
-        :return: The Coop info dictionary.
-        """
+    def push(self, refresh: bool = False) -> Dict[str, Any]:
         if self.coop_info is None or refresh:
             self.coop_info = self.object.push(description=self.description)
             print(
@@ -140,34 +85,13 @@ class ObjectEntry:
                 f"Object {self.variable_name} already pushed to coop with info: {self._coop_info}"
             )
 
-    def __eq__(self, other: "ObjectEntry") -> bool:
-        """
-        Check if two ObjectEntry instances are equal.
-
-        :param other: The other ObjectEntry instance.
-        :return: True if the two instances are equal, False otherwise.
-        """
-        # if the other item is not "ObjectEntry" type, return False
-        if not isinstance(other, ObjectEntry):
-            return False
-
-        return (
-            self.variable_name == other.variable_name
-            and self.object == other.object
-            and self.description == other.description
-            and self.coop_info == other.coop_info
-            and self.created_at == other.created_at
-            and self.edsl_class_name == other.edsl_class_name
-        )
-
 
 if __name__ == "__main__":
     from edsl import QuestionFreeText
-    from edsl.study import ObjectEntry
 
     q = QuestionFreeText.example()
 
     oe = ObjectEntry("q", q, "This is a question")
     d = oe.to_dict()
     new_oe = ObjectEntry.from_dict(d)
-    new_oe == oe
+    # print(oe.coop_info)

edsl/study/ProofOfWork.py

@@ -1,6 +1,6 @@
 import hashlib
 import time
-from typing import Any, Dict, List, Optional
+from typing import Optional, Any, Dict, List
 
 
 class ProofOfWork:
@@ -16,10 +16,7 @@ class ProofOfWork:
         self.input_data = input_data
 
     def to_dict(self) -> Dict[str, Any]:
-        return {
-            "input_data": self.input_data,
-            "proof": self.proof,
-        }
+        return {"input_data": self.input_data, "proof": self.proof}
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "ProofOfWork":

edsl/study/SnapShot.py

@@ -1,11 +1,16 @@
+from typing import Generator
 import inspect
-from typing import Generator, List, Optional
 
 
 class SnapShot:
-    def __init__(self, namespace, exclude: Optional[List] = None):
+    def __init__(self, namespace, exclude=None):
         self.namespace = namespace
-        self.exclude = exclude or []
+
+        if exclude is None:
+            self.exclude = []
+        else:
+            self.exclude = exclude
+
         self.edsl_objects = dict(self._get_edsl_objects(namespace=self.namespace))
         self.edsl_classes = dict(self._get_edsl_classes(namespace=self.namespace))
 
@@ -58,7 +63,6 @@ class SnapShot:
         from edsl.study.Study import Study
 
         for name, value in namespace.items():
-            # TODO check this code logic (if there are other objects with to_dict method that are not from edsl)
             if (
                 hasattr(value, "to_dict")
                 and not inspect.isclass(value)

edsl/study/Study.py

@@ -1,19 +1,23 @@
-import copy
-import inspect
-import json
 import os
 import platform
 import socket
+import copy
+import inspect
+import json
+from typing import Optional, List, Dict
 from datetime import datetime
-from typing import Dict, Optional, Union
+
+# from edsl.Base import Base
 from edsl import Cache, set_session_cache, unset_session_cache
 from edsl.utilities.utilities import dict_hash
+
 from edsl.study.ObjectEntry import ObjectEntry
 from edsl.study.ProofOfWork import ProofOfWork
 from edsl.study.SnapShot import SnapShot
-from uuid import UUID
 
-# from edsl.Base import Base
+
+class _StudyFrameMarker:
+    pass
 
 
 class Study:
@@ -54,7 +58,7 @@ class Study:
         proof_of_work=None,
         proof_of_work_difficulty: int = None,
         namespace: Optional[dict] = None,
-        verbose: Optional[bool] = True,
+        verbose=True,
     ):
         """
         :param name: The name of the study.
@@ -465,22 +469,11 @@ class Study:
 
     def push(self, refresh=False) -> None:
         """Push the objects to coop."""
-
-        from edsl import Coop
-
-        coop = Coop()
-        coop.create(self, description=self.description)
-
-    @classmethod
-    def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
-        """Pull the object from coop."""
-        from edsl.coop import Coop
-
-        coop = Coop()
-        return coop.get(uuid, url, "study")
+        for obj_entry in self.objects.values():
+            obj_entry.push(refresh=refresh)
 
     def __repr__(self):
-        return f"""Study(name = "{self.name}", description = "{self.description}", objects = {self.objects}, cache = {self.cache}, filename = "{self.filename}", coop = {self.coop}, use_study_cache = {self.use_study_cache}, overwrite_on_change = {self.overwrite_on_change})"""
+        return f"""Study(name = {self.name}, description = {self.description}, objects = {self.objects}, cache = {self.cache}, filename = "{self.filename}", coop = {self.coop}, use_study_cache = {self.use_study_cache}, overwrite_on_change = {self.overwrite_on_change})"""
 
 
 if __name__ == "__main__":

edsl/study/__init__.py

@@ -1,4 +1,2 @@
 from edsl.study.ObjectEntry import ObjectEntry
 from edsl.study.ProofOfWork import ProofOfWork
-from edsl.study.SnapShot import SnapShot
-from edsl.study.Study import Study

edsl/surveys/MemoryPlan.py

@@ -3,9 +3,9 @@
 from collections import UserDict, defaultdict
 from typing import Optional
 
-# from edsl.surveys.Memory import Memory
-# from edsl.prompts.Prompt import Prompt
-# from edsl.surveys.DAG import DAG
+from edsl.surveys.Memory import Memory
+from edsl.prompts.Prompt import Prompt
+from edsl.surveys.DAG import DAG
 
 
 class MemoryPlan(UserDict):
@@ -61,8 +61,6 @@ class MemoryPlan(UserDict):
         :param answers: A dictionary of question names to answers.
 
         """
-        from edsl.prompts.Prompt import Prompt
-
         self._check_valid_question_name(focal_question)
 
         if focal_question not in self:
@@ -123,7 +121,6 @@ class MemoryPlan(UserDict):
         self._check_valid_question_name(focal_question)
         self._check_valid_question_name(prior_question)
         self._check_order(focal_question, prior_question)
-        from edsl.surveys.Memory import Memory
 
         if focal_question not in self:
             memory = Memory()
@@ -163,8 +160,6 @@ class MemoryPlan(UserDict):
     @classmethod
     def from_dict(cls, data) -> "MemoryPlan":
         """Deserialize a memory plan from a dictionary."""
-        from edsl.surveys.Memory import Memory
-
         newdata = {}
         for question_name, memory in data["data"].items():
             newdata[question_name] = Memory.from_dict(memory)
@@ -187,15 +182,13 @@ class MemoryPlan(UserDict):
         return new_d
 
     @property
-    def dag(self) -> "DAG":
+    def dag(self) -> DAG:
         """Return a directed acyclic graph of the memory plan.
 
         >>> mp = MemoryPlan.example()
         >>> mp.dag
         {1: {0}}
         """
-        from edsl.surveys.DAG import DAG
-
         d = defaultdict(set)
         for focal_question, memory in self.items():
             for prior_question in memory:

edsl/surveys/Survey.py

@@ -5,6 +5,9 @@ import re
 
 from typing import Any, Generator, Optional, Union, List, Literal, Callable
 
+from rich import print
+from rich.table import Table
+
 from edsl.exceptions import SurveyCreationError, SurveyHasNoRulesError
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.surveys.base import RulePriority, EndOfSurvey
@@ -15,8 +18,8 @@ from edsl.Base import Base
 from edsl.surveys.SurveyExportMixin import SurveyExportMixin
 from edsl.surveys.descriptors import QuestionsDescriptor
 from edsl.surveys.MemoryPlan import MemoryPlan
-
 from edsl.surveys.DAG import DAG
+from edsl.utilities import is_notebook
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 from edsl.surveys.SurveyFlowVisualizationMixin import SurveyFlowVisualizationMixin
 
@@ -93,10 +96,6 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         index = self.question_name_to_index[question_name]
         return self._questions[index]
 
-    def question_names_to_questions(self) -> dict:
-        """Return a dictionary mapping question names to question attributes."""
-        return {q.question_name: q for q in self.questions}
-
     def get_question(self, question_name: str) -> QuestionBase:
         """Return the question object given the question name."""
         # import warnings
@@ -113,10 +112,6 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
     def parameters(self):
         return set.union(*[q.parameters for q in self.questions])
 
-    @property
-    def parameters_by_question(self):
-        return {q.question_name: q.parameters for q in self.questions}
-
     @property
     def question_names(self) -> list[str]:
         """Return a list of question names in the survey.
@@ -560,12 +555,6 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         job = Jobs(survey=self)
         return job.by(*args)
 
-    def to_jobs(self):
-        """Convert the survey to a Jobs object."""
-        from edsl.jobs.Jobs import Jobs
-
-        return Jobs(survey=self)
-
     def run(self, *args, **kwargs) -> "Results":
         """Turn the survey into a Job and runs it.
 
@@ -743,22 +732,6 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         except IndexError:
             raise
 
-    @property
-    def piping_dag(self) -> DAG:
-        d = {}
-        for question_name, depenencies in self.parameters_by_question.items():
-            if depenencies:
-                question_index = self.question_name_to_index[question_name]
-                for dependency in depenencies:
-                    if dependency not in self.question_name_to_index:
-                        pass
-                    else:
-                        dependency_index = self.question_name_to_index[dependency]
-                        if question_index not in d:
-                            d[question_index] = set()
-                        d[question_index].add(dependency_index)
-        return d
-
     def dag(self, textify: bool = False) -> DAG:
         """Return the DAG of the survey, which reflects both skip-logic and memory.
 
@@ -772,12 +745,10 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         """
         memory_dag = self.memory_plan.dag
         rule_dag = self.rule_collection.dag
-        piping_dag = self.piping_dag
         if textify:
             memory_dag = DAG(self.textify(memory_dag))
             rule_dag = DAG(self.textify(rule_dag))
-            piping_dag = DAG(self.textify(piping_dag))
-        return memory_dag + rule_dag + piping_dag
+        return memory_dag + rule_dag
 
     ###################
     # DUNDER METHODS
@@ -960,8 +931,6 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         │ └───────────────┴─────────────────┴───────────────┴──────────────────────────────────────────────┘ │
         └────────────────────────────────────────────────────────────────────────────────────────────────────┘
         """
-        from rich.table import Table
-
         table = Table(show_header=True, header_style="bold magenta")
         table.add_column("Questions", style="dim")
 
@@ -1025,7 +994,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         return res
 
     @classmethod
-    def example(cls, params=False) -> Survey:
+    def example(cls) -> Survey:
         """Return an example survey.
 
         >>> s = Survey.example()
@@ -1049,20 +1018,12 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
             question_options=["**lack*** of killer bees in cafeteria", "other"],
             question_name="q2",
         )
-        if params:
-            q3 = QuestionMultipleChoice(
-                question_text="To the question '{{ q0.question_text}}', you said '{{ q0.answer }}'. Do you still feel this way?",
-                question_options=["yes", "no"],
-                question_name="q3",
-            )
-            s = cls(questions=[q0, q1, q2, q3])
-            return s
         s = cls(questions=[q0, q1, q2])
         s = s.add_rule(q0, "q0 == 'yes'", q2)
         return s
 
     def get_job(self, model=None, agent=None, **kwargs):
-        if model is None:
+        if not model:
             from edsl import Model
 
             model = Model()

edsl/surveys/SurveyExportMixin.py

@@ -1,6 +1,8 @@
 """A mixin class for exporting surveys to different formats."""
 
+from docx import Document
 from typing import Union, Optional
+import black
 
 
 class SurveyExportMixin:
@@ -27,8 +29,6 @@ class SurveyExportMixin:
 
     def docx(self, filename=None) -> Union["Document", None]:
         """Generate a docx document for the survey."""
-        from docx import Document
-
         doc = Document()
         doc.add_heading("EDSL Survey")
         doc.add_paragraph(f"\n")
@@ -83,8 +83,6 @@ class SurveyExportMixin:
         survey = Survey(questions=[q0, q1, q2])
         ...
         """
-        import black
-
         header_lines = ["from edsl.surveys.Survey import Survey"]
         header_lines.append("from edsl import Question")
         lines = ["\n".join(header_lines)]

edsl/surveys/SurveyFlowVisualizationMixin.py

@@ -1,7 +1,10 @@
 """A mixin for visualizing the flow of a survey."""
 
-from edsl.surveys.base import RulePriority, EndOfSurvey
+import pydot
 import tempfile
+from IPython.display import Image
+from edsl.utilities import is_notebook
+from edsl.surveys.base import RulePriority, EndOfSurvey
 
 
 class SurveyFlowVisualizationMixin:
@@ -10,8 +13,6 @@ class SurveyFlowVisualizationMixin:
     def show_flow(self, filename: str = None):
         """Create an image showing the flow of users through the survey."""
         # Create a graph object
-        import pydot
-
         graph = pydot.Dot(graph_type="digraph")
 
         # Add nodes for each question
@@ -100,11 +101,8 @@ class SurveyFlowVisualizationMixin:
                         on Ubuntu.
                     """
                 )
-            from edsl.utilities.utilities import is_notebook
 
             if is_notebook():
-                from IPython.display import Image
-
                 display(Image(tmp_file.name))
             else:
                 import os