edsl 0.1.27.dev2__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,14 +1,14 @@
 """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
-from rich.table import Table
+import os
 
 from edsl.Base import Base
-
 from edsl.scenarios.ScenarioImageMixin import ScenarioImageMixin
 from edsl.scenarios.ScenarioHtmlMixin import ScenarioHtmlMixin
 
@@ -19,7 +19,9 @@ from edsl.utilities.decorators import (
 
 
 class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
-    """A Scenario is a dictionary of keys/values for parameterizing questions."""
+    """A Scenario is a dictionary of keys/values.
+
+    They can be used parameterize edsl questions."""
 
     def __init__(self, data: Union[dict, None] = None, name: str = None):
         """Initialize a new Scenario.
@@ -32,7 +34,7 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         self.name = name
 
     def replicate(self, n: int) -> "ScenarioList":
-        """Replicate a scenario n times.
+        """Replicate a scenario n times to return a ScenarioList.
 
         :param n: The number of times to replicate the scenario.
 
@@ -58,7 +60,7 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         self._has_image = value
 
     def __add__(self, other_scenario: "Scenario") -> "Scenario":
-        """Combine two scenarios.
+        """Combine two scenarios by taking the union of their keys
 
         If the other scenario is None, then just return self.
 
@@ -102,6 +104,17 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
                 new_scenario[key] = value
         return new_scenario
 
+    def _to_dict(self) -> dict:
+        """Convert a scenario to a dictionary.
+
+        Example:
+
+        >>> s = Scenario({"food": "wood chips"})
+        >>> s.to_dict()
+        {'food': 'wood chips', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
+        """
+        return self.data.copy()
+
     @add_edsl_version
     def to_dict(self) -> dict:
         """Convert a scenario to a dictionary.
@@ -112,7 +125,21 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         >>> s.to_dict()
         {'food': 'wood chips', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
         """
-        return self.data.copy()
+        return self._to_dict()
+
+    def __hash__(self) -> int:
+        """
+        Return a hash of the scenario.
+
+        Example:
+
+        >>> s = Scenario({"food": "wood chips"})
+        >>> hash(s)
+        1153210385458344214
+        """
+        from edsl.utilities.utilities import dict_hash
+
+        return dict_hash(self._to_dict())
 
     def print(self):
         from rich import print_json
@@ -183,6 +210,30 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
             s.has_image = True
             return s
 
+    @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.")
+
+        # Open the PDF file
+        document = fitz.open(pdf_path)
+
+        # Get the filename from the path
+        filename = os.path.basename(pdf_path)
+
+        # Iterate through each page and extract text
+        text = ""
+        for page_num in range(len(document)):
+            page = document.load_page(page_num)
+            text = text + page.get_text()
+
+        # Create a dictionary for the combined text
+        page_info = {"filename": filename, "text": text}
+        return Scenario(page_info)
+
     @classmethod
     def from_docx(cls, docx_path: str) -> "Scenario":
         """Creates a scenario from the text of a docx file.
@@ -350,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

@@ -2,28 +2,25 @@
 
 from __future__ import annotations
 import csv
-from collections import UserList
+import random
+from collections import UserList, Counter
 from collections.abc import Iterable
-from collections import Counter
-
 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
 
-import pandas as pd
-
-from edsl.utilities.interface import print_scenario_list
 
-from edsl.utilities import is_valid_variable_name
+class ScenarioListMixin(ScenarioListPdfMixin, ScenarioListExportMixin):
+    pass
 
 
-class ScenarioList(Base, UserList, ScenarioListPdfMixin):
+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):
@@ -33,11 +30,37 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         else:
             super().__init__([])
 
+    @property
+    def parameters(self) -> set:
+        """Return the set of parameters in the ScenarioList
+
+        Example:
+
+        >>> s = ScenarioList([Scenario({'a': 1}), Scenario({'b': 2})])
+        >>> s.parameters == {'a', 'b'}
+        True
+        """
+        if len(self) == 0:
+            return set()
+
+        return set.union(*[set(s.keys()) for s in self])
+
+    def __hash__(self) -> int:
+        """Return the hash of the ScenarioList.
+
+        >>> s = ScenarioList.example()
+        >>> hash(s)
+        1262252885757976162
+        """
+        from edsl.utilities.utilities import dict_hash
+
+        return dict_hash(self._to_dict(sort=True))
+
     def __repr__(self):
         return f"ScenarioList({self.data})"
 
     def __mul__(self, other: ScenarioList) -> ScenarioList:
-        """Return a ScenarioList with the scenarios repeated n times."""
+        """Takes the cross product of two ScenarioLists."""
         from itertools import product
 
         new_sl = []
@@ -45,6 +68,24 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
             new_sl.append(s1 + s2)
         return ScenarioList(new_sl)
 
+    def times(self, other: ScenarioList) -> ScenarioList:
+        """Takes the cross product of two ScenarioLists.
+
+        Example:
+
+        >>> s1 = ScenarioList([Scenario({'a': 1}), Scenario({'a': 2})])
+        >>> s2 = ScenarioList([Scenario({'b': 1}), Scenario({'b': 2})])
+        >>> s1.times(s2)
+        ScenarioList([Scenario({'a': 1, 'b': 1}), Scenario({'a': 1, 'b': 2}), Scenario({'a': 2, 'b': 1}), Scenario({'a': 2, 'b': 2})])
+        """
+        return self.__mul__(other)
+
+    def shuffle(self, seed: Optional[str] = "edsl") -> ScenarioList:
+        """Shuffle the ScenarioList."""
+        random.seed(seed)
+        random.shuffle(self.data)
+        return self
+
     def _repr_html_(self) -> str:
         from edsl.utilities.utilities import data_to_html
 
@@ -69,14 +110,13 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
 
     def sample(self, n: int, seed="edsl") -> ScenarioList:
         """Return a random sample from the ScenarioList"""
-        import random
 
         if seed != "edsl":
             random.seed(seed)
 
         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:
@@ -90,9 +130,11 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
             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)
 
@@ -112,6 +154,8 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
             )
         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.")
 
@@ -135,16 +179,20 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
 
         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:
         """
@@ -217,6 +265,13 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         """
         return cls([Scenario({name: value}) for value in values])
 
+    def to_dataset(self) -> "Dataset":
+        from edsl.results.Dataset import Dataset
+
+        keys = self[0].keys()
+        data = {key: [scenario[key] for scenario in self.data] for key in keys}
+        return Dataset([data])
+
     def add_list(self, name, values) -> ScenarioList:
         """Add a list of values to a ScenarioList.
 
@@ -227,7 +282,10 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         ScenarioList([Scenario({'name': 'Alice', 'age': 30}), Scenario({'name': 'Bob', 'age': 25})])
         """
         for i, value in enumerate(values):
-            self[i][name] = value
+            if i < len(self):
+                self[i][name] = value
+            else:
+                self.append(Scenario({name: value}))
         return self
 
     def add_value(self, name, value):
@@ -244,6 +302,16 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         return self
 
     def rename(self, replacement_dict: dict) -> ScenarioList:
+        """Rename the fields in the scenarios.
+
+        Example:
+
+        >>> s = ScenarioList([Scenario({'name': 'Alice', 'age': 30}), Scenario({'name': 'Bob', 'age': 25})])
+        >>> s.rename({'name': 'first_name', 'age': 'years'})
+        ScenarioList([Scenario({'first_name': 'Alice', 'years': 30}), Scenario({'first_name': 'Bob', 'years': 25})])
+
+        """
+
         new_list = ScenarioList([])
         for obj in self:
             new_obj = obj.rename(replacement_dict)
@@ -274,6 +342,20 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         """
         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.
@@ -293,6 +375,8 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         >>> scenario_list[1]['age']
         '25'
         """
+        from edsl.scenarios.Scenario import Scenario
+
         observations = []
         with open(filename, "r") as f:
             reader = csv.reader(f)
@@ -301,6 +385,13 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
                 observations.append(Scenario(dict(zip(header, row))))
         return cls(observations)
 
+    def _to_dict(self, sort=False) -> dict:
+        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.
@@ -315,13 +406,24 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
 
     @classmethod
     def gen(cls, scenario_dicts_list: List[dict]) -> ScenarioList:
-        """Create a `ScenarioList` from a list of dictionaries."""
+        """Create a `ScenarioList` from a list of dictionaries.
+
+        Example:
+
+        >>> ScenarioList.gen([{'name': 'Alice'}, {'name': 'Bob'}])
+        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:
@@ -346,6 +448,8 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
 
     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")
@@ -360,40 +464,22 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         pretty_labels: Optional[dict] = None,
         filename: str = None,
     ):
-        print_scenario_list(self)
-        # if format is None:
-        #     if is_notebook():
-        #         format = "html"
-        #     else:
-        #         format = "rich"
-
-        # if pretty_labels is None:
-        #     pretty_labels = {}
-
-        # if format not in ["rich", "html", "markdown"]:
-        #     raise ValueError("format must be one of 'rich', 'html', or 'markdown'.")
-
-        # if max_rows is not None:
-        #     new_data = self[:max_rows]
-        # else:
-        #     new_data = self
-
-        # if format == "rich":
-        #     print_list_of_dicts_with_rich(
-        #         new_data, filename=filename, split_at_dot=False
-        #     )
-        # elif format == "html":
-        #     notebook = is_notebook()
-        #     html = print_list_of_dicts_as_html_table(
-        #         new_data, filename=None, interactive=False, notebook=notebook
-        #     )
-        #     # print(html)
-        #     display(HTML(html))
-        # elif format == "markdown":
-        #     print_list_of_dicts_as_markdown_table(new_data, filename=filename)
+        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."""
+        """Return the item at the given index.
+
+        Example:
+        >>> s = ScenarioList([Scenario({'age': 22, 'hair': 'brown', 'height': 5.5}), Scenario({'age': 22, 'hair': 'brown', 'height': 5.5})])
+        >>> s[0]
+        Scenario({'age': 22, 'hair': 'brown', 'height': 5.5})
+
+        >>> s[:1]
+        ScenarioList([Scenario({'age': 22, 'hair': 'brown', 'height': 5.5})])
+
+        """
         if isinstance(key, slice):
             return ScenarioList(super().__getitem__(key))
         elif isinstance(key, int):

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