edsl 0.1.29.dev6__py3-none-any.whl → 0.1.30__py3-none-any.whl

edsl/scenarios/FileStore.py

@@ -0,0 +1,299 @@
+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 __repr__(self):
+        return f"FileStore(filename='{self.filename}', binary='{self.binary}', 'suffix'={self.suffix})"
+
+    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
+        mode = "wb" if self.binary else "w"
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix, mode=mode)
+
+        if self.binary:
+            temp_file.write(file_like_object.read())
+        else:
+            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")
+
+    @classmethod
+    def example(cls):
+        from edsl.results.Results import Results
+
+        r = Results.example()
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".csv", delete=False) as f:
+            r.to_csv(filename=f.name)
+            return cls(f.name)
+
+    def view(self):
+        import pandas as pd
+
+        return pd.read_csv(self.to_tempfile())
+
+
+class PDFFileStore(FileStore):
+    def __init__(self, filename):
+        super().__init__(filename, suffix=".pdf")
+
+    def view(self):
+        pdf_path = self.to_tempfile()
+        print(f"PDF path: {pdf_path}")  # Print the path to ensure it exists
+        import os
+        import subprocess
+
+        if os.path.exists(pdf_path):
+            try:
+                if os.name == "posix":
+                    # for cool kids
+                    subprocess.run(["open", pdf_path], check=True)  # macOS
+                elif os.name == "nt":
+                    os.startfile(pdf_path)  # Windows
+                else:
+                    subprocess.run(["xdg-open", pdf_path], check=True)  # Linux
+            except Exception as e:
+                print(f"Error opening PDF: {e}")
+        else:
+            print("PDF file was not created successfully.")
+
+    @classmethod
+    def example(cls):
+        import textwrap
+
+        pdf_string = textwrap.dedent(
+            """\
+        %PDF-1.4
+        1 0 obj
+        << /Type /Catalog /Pages 2 0 R >>
+        endobj
+        2 0 obj
+        << /Type /Pages /Kids [3 0 R] /Count 1 >>
+        endobj
+        3 0 obj
+        << /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>
+        endobj
+        4 0 obj
+        << /Length 44 >>
+        stream
+        BT
+        /F1 24 Tf
+        100 700 Td
+        (Hello, World!) Tj
+        ET
+        endstream
+        endobj
+        5 0 obj
+        << /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
+        endobj
+        6 0 obj
+        << /ProcSet [/PDF /Text] /Font << /F1 5 0 R >> >>
+        endobj
+        xref
+        0 7
+        0000000000 65535 f 
+        0000000010 00000 n 
+        0000000053 00000 n 
+        0000000100 00000 n 
+        0000000173 00000 n 
+        0000000232 00000 n 
+        0000000272 00000 n 
+        trailer
+        << /Size 7 /Root 1 0 R >>
+        startxref
+        318
+        %%EOF"""
+        )
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as f:
+            f.write(pdf_string.encode())
+            return cls(f.name)
+
+
+class PNGFileStore(FileStore):
+    def __init__(self, filename):
+        super().__init__(filename, suffix=".png")
+
+    @classmethod
+    def example(cls):
+        import textwrap
+
+        png_string = textwrap.dedent(
+            """\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x01\x00\x00\x00\x01\x00\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0cIDAT\x08\xd7c\x00\x01"""
+        )
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
+            f.write(png_string.encode())
+            return cls(f.name)
+
+    def view(self):
+        import matplotlib.pyplot as plt
+        import matplotlib.image as mpimg
+
+        img = mpimg.imread(self.to_tempfile())
+        plt.imshow(img)
+        plt.show()
+
+
+class SQLiteFileStore(FileStore):
+    def __init__(self, filename):
+        super().__init__(filename, suffix=".sqlite")
+
+    @classmethod
+    def example(cls):
+        import sqlite3
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".sqlite", delete=False) as f:
+            conn = sqlite3.connect(f.name)
+            c = conn.cursor()
+            c.execute("""CREATE TABLE stocks (date text)""")
+            conn.commit()
+
+    def view(self):
+        import subprocess
+        import os
+
+        sqlite_path = self.to_tempfile()
+        os.system(f"sqlite3 {sqlite_path}")
+
+
+if __name__ == "__main__":
+    # file_path = "../conjure/examples/Ex11-2.sav"
+    # fs = FileStore(file_path)
+    # info = fs.push()
+    # print(info)
+
+    # fs = CSVFileStore.example()
+    # fs.to_tempfile()
+    # print(fs.view())
+
+    # fs = PDFFileStore.example()
+    # fs.view()
+
+    # fs = PDFFileStore("paper.pdf")
+    # fs.view()
+    # from edsl import Conjure
+
+    fs = PNGFileStore("robot.png")
+    fs.view()
+
+    # c = Conjure(datafile_name=fs.to_tempfile())
+    # f = PDFFileStore("paper.pdf")
+    # print(f.to_tempfile())
+    # f.push()

edsl/scenarios/Scenario.py

@@ -1,26 +1,17 @@
 """A Scenario is a dictionary with a key/value to parameterize a question."""
 
+from __future__ import annotations
 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 collections import UserDict
+from typing import Union, List, Optional, Generator
+from uuid import uuid4
 from edsl.Base import Base
 from edsl.scenarios.ScenarioImageMixin import ScenarioImageMixin
 from edsl.scenarios.ScenarioHtmlMixin import ScenarioHtmlMixin
-
-from edsl.utilities.decorators import (
-    add_edsl_version,
-    remove_edsl_version,
-)
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
@@ -33,9 +24,7 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
 
         :param data: A dictionary of keys/values for parameterizing questions.
         """
-        if data is None:
-            data = {}
-        self.data = data
+        self.data = data if data is not None else {}
         self.name = name
 
     def replicate(self, n: int) -> "ScenarioList":
@@ -217,6 +206,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 +395,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:
@@ -416,17 +409,16 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         return table
 
     @classmethod
-    def example(cls) -> "Scenario":
-        """Return an example scenario.
-
-        Example:
+    def example(cls, randomize: bool = False) -> Scenario:
+        """
+        Returns an example Scenario instance.
 
-        >>> Scenario.example()
-        Scenario({'persona': 'A reseacher studying whether LLMs can be used to generate surveys.'})
+        :param randomize: If True, adds a random string to the value of the example key.
         """
+        addition = "" if not randomize else str(uuid4())
         return cls(
             {
-                "persona": "A reseacher studying whether LLMs can be used to generate surveys."
+                "persona": f"A reseacher studying whether LLMs can be used to generate surveys.{addition}",
             }
         )
 

edsl/scenarios/ScenarioList.py

@@ -5,25 +5,20 @@ 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 typing import Any, Optional, Union, List
 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):
@@ -157,6 +152,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.")
 
@@ -376,6 +373,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)
@@ -413,12 +412,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:
@@ -437,12 +440,18 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
         return lines
 
     @classmethod
-    def example(cls) -> ScenarioList:
-        """Return an example of the `ScenarioList`."""
-        return cls([Scenario.example(), Scenario.example()])
+    def example(cls, randomize: bool = False) -> ScenarioList:
+        """
+        Return an example ScenarioList instance.
+
+        :params randomize: If True, use Scenario's randomize method to randomize the values.
+        """
+        return cls([Scenario.example(randomize), Scenario.example(randomize)])
 
     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")
@@ -457,6 +466,8 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
         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/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/Study.py

@@ -6,14 +6,12 @@ import platform
 import socket
 from datetime import datetime
 from typing import Dict, Optional, Union
+from uuid import UUID, uuid4
 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 Study:
@@ -402,14 +400,14 @@ class Study:
         return diff
 
     @classmethod
-    def example(cls, verbose=False):
+    def example(cls, verbose=False, randomize=False):
         import tempfile
 
         study_file = tempfile.NamedTemporaryFile()
         with cls(filename=study_file.name, verbose=verbose) as study:
             from edsl import QuestionFreeText
 
-            q = QuestionFreeText.example()
+            q = QuestionFreeText.example(randomize=randomize)
         return study
 
     @classmethod
@@ -463,13 +461,13 @@ class Study:
         else:
             self.objects[oe.hash] = oe
 
-    def push(self, refresh=False) -> None:
+    def push(self) -> dict:
         """Push the objects to coop."""
 
         from edsl import Coop
 
         coop = Coop()
-        coop.create(self, description=self.description)
+        return coop.create(self, description=self.description)
 
     @classmethod
     def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):

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,6 +61,8 @@ 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:
@@ -121,6 +123,7 @@ 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()
@@ -160,6 +163,8 @@ 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)
@@ -182,13 +187,15 @@ 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: