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

edsl/scenarios/FileStore.py

@@ -0,0 +1,140 @@
+from edsl import Scenario
+import base64
+import io
+import tempfile
+from typing import Optional
+
+
+class FileStore(Scenario):
+    def __init__(
+        self,
+        filename: str,
+        binary: Optional[bool] = None,
+        suffix: Optional[str] = None,
+        base64_string: Optional[str] = None,
+    ):
+        self.filename = filename
+        self.suffix = suffix or "." + filename.split(".")[-1]
+        self.binary = binary or False
+        self.base64_string = base64_string or self.encode_file_to_base64_string(
+            filename
+        )
+        super().__init__(
+            {
+                "filename": self.filename,
+                "base64_string": self.base64_string,
+                "binary": self.binary,
+                "suffix": self.suffix,
+            }
+        )
+
+    @classmethod
+    def from_dict(cls, d):
+        return cls(d["filename"], d["binary"], d["suffix"], d["base64_string"])
+
+    def encode_file_to_base64_string(self, file_path):
+        try:
+            # Attempt to open the file in text mode
+            with open(file_path, "r") as text_file:
+                # Read the text data
+                text_data = text_file.read()
+                # Encode the text data to a base64 string
+                base64_encoded_data = base64.b64encode(text_data.encode("utf-8"))
+        except UnicodeDecodeError:
+            # If reading as text fails, open the file in binary mode
+            with open(file_path, "rb") as binary_file:
+                # Read the binary data
+                binary_data = binary_file.read()
+                # Encode the binary data to a base64 string
+                base64_encoded_data = base64.b64encode(binary_data)
+                self.binary = True
+        # Convert the base64 bytes to a string
+        base64_string = base64_encoded_data.decode("utf-8")
+
+        return base64_string
+
+    def open(self):
+        if self.binary:
+            return self.base64_to_file(self["base64_string"], is_binary=True)
+        else:
+            return self.base64_to_text_file(self["base64_string"])
+
+    @staticmethod
+    def base64_to_text_file(base64_string):
+        # Decode the base64 string to bytes
+        text_data_bytes = base64.b64decode(base64_string)
+
+        # Convert bytes to string
+        text_data = text_data_bytes.decode("utf-8")
+
+        # Create a StringIO object from the text data
+        text_file = io.StringIO(text_data)
+
+        return text_file
+
+    @staticmethod
+    def base64_to_file(base64_string, is_binary=True):
+        # Decode the base64 string to bytes
+        file_data = base64.b64decode(base64_string)
+
+        if is_binary:
+            # Create a BytesIO object for binary data
+            return io.BytesIO(file_data)
+        else:
+            # Convert bytes to string for text data
+            text_data = file_data.decode("utf-8")
+            # Create a StringIO object for text data
+            return io.StringIO(text_data)
+
+    def to_tempfile(self, suffix=None):
+        if suffix is None:
+            suffix = self.suffix
+        if self.binary:
+            file_like_object = self.base64_to_file(
+                self["base64_string"], is_binary=True
+            )
+        else:
+            file_like_object = self.base64_to_text_file(self["base64_string"])
+
+        # Create a named temporary file
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
+        temp_file.write(file_like_object.read())
+        temp_file.close()
+
+        return temp_file.name
+
+    def push(self, description=None):
+        scenario_version = Scenario.from_dict(self.to_dict())
+        if description is None:
+            description = "File: " + self["filename"]
+        info = scenario_version.push(description=description)
+        return info
+
+    @classmethod
+    def pull(cls, uuid):
+        scenario_version = Scenario.pull(uuid)
+        return cls.from_dict(scenario_version.to_dict())
+
+
+class CSVFileStore(FileStore):
+    def __init__(self, filename):
+        super().__init__(filename, suffix=".csv")
+
+
+class PDFFileStore(FileStore):
+    def __init__(self, filename):
+        super().__init__(filename, suffix=".pdf")
+
+
+if __name__ == "__main__":
+    # file_path = "../conjure/examples/Ex11-2.sav"
+    # fs = FileStore(file_path)
+    # info = fs.push()
+    # print(info)
+
+    # from edsl import Conjure
+
+    # c = Conjure(datafile_name=fs.to_tempfile())
+    f = PDFFileStore("paper.pdf")
+    # print(f.to_tempfile())
+    f.push()

edsl/scenarios/Scenario.py

@@ -1,17 +1,12 @@
 """A Scenario is a dictionary with a key/value to parameterize a question."""
 
+import time
 import copy
 from collections import UserDict
 from typing import Union, List, Optional, Generator
 import base64
 import hashlib
-import json
-
-import fitz  # PyMuPDF
 import os
-import subprocess
-
-from rich.table import Table
 
 from edsl.Base import Base
 from edsl.scenarios.ScenarioImageMixin import ScenarioImageMixin
@@ -217,6 +212,8 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
 
     @classmethod
     def from_pdf(cls, pdf_path):
+        import fitz  # PyMuPDF
+
         # Ensure the file exists
         if not os.path.exists(pdf_path):
             raise FileNotFoundError(f"The file {pdf_path} does not exist.")
@@ -404,6 +401,8 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
 
     def rich_print(self) -> "Table":
         """Display an object as a rich table."""
+        from rich.table import Table
+
         table_data, column_names = self._table()
         table = Table(title=f"{self.__class__.__name__} Attributes")
         for column in column_names:

edsl/scenarios/ScenarioList.py

@@ -5,25 +5,22 @@ 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
 
-from edsl.utilities import is_valid_variable_name
+class ScenarioListMixin(ScenarioListPdfMixin, ScenarioListExportMixin):
+    pass
 
-from edsl.results.ResultsExportMixin import ResultsExportMixin
 
-
-class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
+class ScenarioList(Base, UserList, ScenarioListMixin):
     """Class for creating a list of scenarios to be used in a survey."""
 
     def __init__(self, data: Optional[list] = None):
@@ -119,7 +116,7 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
 
         return ScenarioList(random.sample(self.data, n))
 
-    def expand(self, expand_field: str) -> ScenarioList:
+    def expand(self, expand_field: str, number_field=False) -> ScenarioList:
         """Expand the ScenarioList by a field.
 
         Example:
@@ -133,9 +130,11 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
             values = scenario[expand_field]
             if not isinstance(values, Iterable) or isinstance(values, str):
                 values = [values]
-            for value in values:
+            for index, value in enumerate(values):
                 new_scenario = scenario.copy()
                 new_scenario[expand_field] = value
+                if number_field:
+                    new_scenario[expand_field + "_number"] = index + 1
                 new_scenarios.append(new_scenario)
         return ScenarioList(new_scenarios)
 
@@ -155,6 +154,8 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
             )
         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.")
 
@@ -178,16 +179,20 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
 
         return ScenarioList(new_data)
 
-    def order_by(self, field: str, reverse: bool = False) -> ScenarioList:
-        """Order the scenarios by a field.
+    def order_by(self, *fields: str, reverse: bool = False) -> ScenarioList:
+        """Order the scenarios by one or more fields.
 
         Example:
 
         >>> s = ScenarioList([Scenario({'a': 1, 'b': 2}), Scenario({'a': 1, 'b': 1})])
-        >>> s.order_by('b')
+        >>> s.order_by('b', 'a')
         ScenarioList([Scenario({'a': 1, 'b': 1}), Scenario({'a': 1, 'b': 2})])
         """
-        return ScenarioList(sorted(self, key=lambda x: x[field], reverse=reverse))
+
+        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:
         """
@@ -337,6 +342,20 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
         """
         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.
@@ -356,6 +375,8 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
         >>> scenario_list[1]['age']
         '25'
         """
+        from edsl.scenarios.Scenario import Scenario
+
         observations = []
         with open(filename, "r") as f:
             reader = csv.reader(f)
@@ -393,12 +414,16 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
         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:
@@ -423,6 +448,8 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
 
     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")
@@ -437,7 +464,9 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
         pretty_labels: Optional[dict] = None,
         filename: str = None,
     ):
-        print_scenario_list(self)
+        from edsl.utilities.interface import print_scenario_list
+
+        print_scenario_list(self[:max_rows])
 
     def __getitem__(self, key: Union[int, slice]) -> Any:
         """Return the item at the given index.

edsl/scenarios/ScenarioListExportMixin.py

@@ -0,0 +1,32 @@
+"""Mixin class for exporting results."""
+
+from functools import wraps
+from edsl.results.DatasetExportMixin import DatasetExportMixin
+
+
+def to_dataset(func):
+    """Convert the Results object to a Dataset object before calling the function."""
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        """Return the function with the Results object converted to a Dataset object."""
+        if self.__class__.__name__ == "ScenarioList":
+            return func(self.to_dataset(), *args, **kwargs)
+        else:
+            raise Exception(
+                f"Class {self.__class__.__name__} not recognized as a Results or Dataset object."
+            )
+
+    return wrapper
+
+
+def decorate_all_methods(cls):
+    for attr_name, attr_value in cls.__dict__.items():
+        if callable(attr_value):
+            setattr(cls, attr_name, to_dataset(attr_value))
+    return cls
+
+
+@decorate_all_methods
+class ScenarioListExportMixin(DatasetExportMixin):
+    """Mixin class for exporting Results objects."""

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,6 +22,7 @@ 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 +1,2 @@
 from edsl.scenarios.Scenario import Scenario
+from edsl.scenarios.ScenarioList import ScenarioList

edsl/study/ObjectEntry.py

@@ -1,5 +1,8 @@
 import time
-from typing import Optional, Dict, Any, Type
+import webbrowser
+from typing import Any, Dict, Optional, Type
+from edsl import QuestionBase
+from edsl.Base import RegisterSubclassesMeta
 
 
 class ObjectEntry:
@@ -12,6 +15,16 @@ 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
@@ -20,22 +33,33 @@ class ObjectEntry:
         self.coop_info = coop_info
 
     @classmethod
-    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"]
+    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"]
         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,
@@ -47,34 +71,65 @@ 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["url"]
-        import webbrowser
-
+        url = self.coop_info.get("url")
         webbrowser.open(url)
 
-    def push(self, refresh: bool = False) -> Dict[str, Any]:
+    def push(self, refresh: Optional[bool] = False) -> Dict[str, Any]:
+        """
+        Push the object to the Coop.
+
+        :param refresh: Whether to refresh the Coop entry for the object.
+        :return: The Coop info dictionary.
+        """
         if self.coop_info is None or refresh:
             self.coop_info = self.object.push(description=self.description)
             print(
@@ -85,13 +140,34 @@ 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)
-    # print(oe.coop_info)
+    new_oe == oe

edsl/study/ProofOfWork.py

@@ -1,6 +1,6 @@
 import hashlib
 import time
-from typing import Optional, Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 
 class ProofOfWork:
@@ -16,7 +16,10 @@ 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,16 +1,11 @@
-from typing import Generator
 import inspect
+from typing import Generator, List, Optional
 
 
 class SnapShot:
-    def __init__(self, namespace, exclude=None):
+    def __init__(self, namespace, exclude: Optional[List] = None):
         self.namespace = namespace
-
-        if exclude is None:
-            self.exclude = []
-        else:
-            self.exclude = exclude
-
+        self.exclude = exclude or []
         self.edsl_objects = dict(self._get_edsl_objects(namespace=self.namespace))
         self.edsl_classes = dict(self._get_edsl_classes(namespace=self.namespace))
 
@@ -63,6 +58,7 @@ 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,23 +1,19 @@
-import os
-import platform
-import socket
 import copy
 import inspect
 import json
-from typing import Optional, List, Dict
+import os
+import platform
+import socket
 from datetime import datetime
-
-# from edsl.Base import Base
+from typing import Dict, Optional, Union
 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
 
-
-class _StudyFrameMarker:
-    pass
+# from edsl.Base import Base
 
 
 class Study:
@@ -58,7 +54,7 @@ class Study:
         proof_of_work=None,
         proof_of_work_difficulty: int = None,
         namespace: Optional[dict] = None,
-        verbose=True,
+        verbose: Optional[bool] = True,
     ):
         """
         :param name: The name of the study.
@@ -469,11 +465,22 @@ class Study:
 
     def push(self, refresh=False) -> None:
         """Push the objects to coop."""
-        for obj_entry in self.objects.values():
-            obj_entry.push(refresh=refresh)
+
+        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")
 
     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,2 +1,4 @@
 from edsl.study.ObjectEntry import ObjectEntry
 from edsl.study.ProofOfWork import ProofOfWork
+from edsl.study.SnapShot import SnapShot
+from edsl.study.Study import Study