edsl 0.1.33.dev2__py3-none-any.whl → 0.1.34__py3-none-any.whl

edsl/questions/derived/QuestionYesNo.py

@@ -19,6 +19,7 @@ class QuestionYesNo(QuestionMultipleChoice):
         question_options: list[str] = ["No", "Yes"],
         answering_instructions: Optional[str] = None,
         question_presentation: Optional[str] = None,
+        include_comment: Optional[bool] = True,
     ):
         """Instantiate a new QuestionYesNo.
 
@@ -33,6 +34,7 @@ class QuestionYesNo(QuestionMultipleChoice):
             use_code=False,
             answering_instructions=answering_instructions,
             question_presentation=question_presentation,
+            include_comment=include_comment,
         )
         self.question_options = question_options
 
@@ -41,9 +43,13 @@ class QuestionYesNo(QuestionMultipleChoice):
     ################
     @classmethod
     @inject_exception
-    def example(cls) -> QuestionYesNo:
+    def example(cls, include_comment: bool = True) -> QuestionYesNo:
         """Return an example of a yes/no question."""
-        return cls(question_name="is_it_equal", question_text="Is 5 + 5 equal to 11?")
+        return cls(
+            question_name="is_it_equal",
+            question_text="Is 5 + 5 equal to 11?",
+            include_comment=include_comment,
+        )
 
 
 def main():

edsl/questions/descriptors.py

@@ -303,7 +303,7 @@ class QuestionOptionsDescriptor(BaseDescriptor):
                 return None
             else:
                 raise QuestionCreationValidationError(
-                    f"Dynamic question options must have jina2 braces - instead received: {value}."
+                    f"Dynamic question options must have jinja2 braces - instead received: {value}."
                 )
         if not isinstance(value, list):
             raise QuestionCreationValidationError(
@@ -325,14 +325,15 @@ class QuestionOptionsDescriptor(BaseDescriptor):
             )
         if not self.linear_scale:
             if not self.q_budget:
-                if not (
-                    value
-                    and all(type(x) == type(value[0]) for x in value)
-                    and isinstance(value[0], (str, list, int, float))
-                ):
-                    raise QuestionCreationValidationError(
-                        f"Question options must be all same type (got {value}).)"
-                    )
+                pass
+            #     if not (
+            #         value
+            #         and all(type(x) == type(value[0]) for x in value)
+            #         and isinstance(value[0], (str, list, int, float))
+            #     ):
+            #         raise QuestionCreationValidationError(
+            #             f"Question options must be all same type (got {value}).)"
+            #         )
             else:
                 if not all(isinstance(x, (str)) for x in value):
                     raise QuestionCreationValidationError(
@@ -390,8 +391,8 @@ class QuestionTextDescriptor(BaseDescriptor):
 
     def validate(self, value, instance):
         """Validate the value is a string."""
-        if len(value) > Settings.MAX_QUESTION_LENGTH:
-            raise Exception("Question is too long!")
+        # if len(value) > Settings.MAX_QUESTION_LENGTH:
+        #     raise Exception("Question is too long!")
         if len(value) < 1:
             raise Exception("Question is too short!")
         if not isinstance(value, str):

edsl/questions/templates/budget/answering_instructions.jinja

@@ -0,0 +1,7 @@
+Return only a comma-separated list the values in the same order as the options, with 0s included, on one line, in square braces.
+
+Example: if there are 4 options, the response should be "[25,25,25,25]" to allocate 25 to each option.
+
+{% if include_comment %}
+After the answer, you can put a comment explaining your choice on the next line.
+{% endif %}

edsl/questions/templates/budget/question_presentation.jinja

@@ -0,0 +1,7 @@
+{{question_text}}
+The options are 
+{% for option in question_options %}
+{{ loop.index0 }}: {{option}}
+{% endfor %}                       
+Allocate your budget of {{budget_sum}} among the options. 
+

edsl/questions/templates/numerical/answering_instructions.jinja

@@ -1,7 +1,6 @@
 This question requires a numerical response in the form of an integer or decimal (e.g., -12, 0, 1, 2, 3.45, ...).
 Respond with just your number on a single line.
 If your response is equivalent to zero, report '0'
-If you cannot determine the answer, report 'None'
 
 {% if include_comment %}
 After the answer, put a comment explaining your choice on the next line.

edsl/questions/templates/yes_no/answering_instructions.jinja

@@ -1,6 +1,6 @@
 {# Answering Instructions #}
-Please reponse with just your answer. 
+Please respond with just your answer. 
 
 {% if include_comment %}
-After the answer, you can put a comment explaining your reponse.
+After the answer, you can put a comment explaining your response.
 {% endif %}

edsl/results/DatasetExportMixin.py

@@ -472,7 +472,11 @@ class DatasetExportMixin:
         from edsl import ScenarioList, Scenario
 
         list_of_dicts = self.to_dicts(remove_prefix=remove_prefix)
-        return ScenarioList([Scenario(d) for d in list_of_dicts])
+        scenarios = []
+        for d in list_of_dicts:
+            scenarios.append(Scenario(d))
+        return ScenarioList(scenarios)
+        # return ScenarioList([Scenario(d) for d in list_of_dicts])
 
     def to_agent_list(self, remove_prefix: bool = True):
         """Convert the results to a list of dictionaries, one per agent.

edsl/results/Result.py

@@ -367,7 +367,7 @@ class Result(Base, UserDict):
                 "raw_model_response", {"raw_model_response": "No raw model response"}
             ),
             question_to_attributes=json_dict.get("question_to_attributes", None),
-            generated_tokens=json_dict.get("generated_tokens", None),
+            generated_tokens=json_dict.get("generated_tokens", {}),
         )
         return result
 

edsl/results/Results.py

@@ -245,7 +245,9 @@ class Results(UserList, Mixins, Base):
         )
 
     def __repr__(self) -> str:
-        return f"Results(data = {self.data}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
+        import reprlib
+
+        return f"Results(data = {reprlib.repr(self.data)}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
 
     def _repr_html_(self) -> str:
         from IPython.display import HTML
@@ -1089,6 +1091,7 @@ class Results(UserList, Mixins, Base):
             stop_on_exception=True,
             skip_retry=True,
             raise_validation_errors=True,
+            disable_remote_inference=True,
         )
         return results
 

edsl/scenarios/FileStore.py

@@ -1,41 +1,101 @@
-from edsl import Scenario
 import base64
 import io
 import tempfile
-from typing import Optional
+import mimetypes
+import os
+from typing import Dict, Any, IO, Optional
+import requests
+from urllib.parse import urlparse
+
+import google.generativeai as genai
+
+from edsl import Scenario
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+from edsl.utilities.utilities import is_notebook
+
+
+def view_pdf(pdf_path):
+    import os
+    import subprocess
+
+    if is_notebook():
+        from IPython.display import IFrame
+        from IPython.display import display, HTML
+
+        # Replace 'path/to/your/file.pdf' with the actual path to your PDF file
+        IFrame(pdf_path, width=700, height=600)
+        display(HTML(f'<a href="{pdf_path}" target="_blank">Open PDF</a>'))
+        return
+
+    if os.path.exists(pdf_path):
+        try:
+            if (os_name := 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.")
 
 
 class FileStore(Scenario):
     def __init__(
         self,
-        filename: str,
+        path: Optional[str] = None,
+        mime_type: Optional[str] = None,
         binary: Optional[bool] = None,
         suffix: Optional[str] = None,
         base64_string: Optional[str] = None,
+        external_locations: Optional[Dict[str, str]] = None,
+        **kwargs,
     ):
-        self.filename = filename
-        self.suffix = suffix or "." + filename.split(".")[-1]
+        if path is None and "filename" in kwargs:
+            path = kwargs["filename"]
+        self.path = path
+        self.suffix = suffix or path.split(".")[-1]
         self.binary = binary or False
-        self.base64_string = base64_string or self.encode_file_to_base64_string(
-            filename
+        self.mime_type = (
+            mime_type or mimetypes.guess_type(path)[0] or "application/octet-stream"
         )
+        self.base64_string = base64_string or self.encode_file_to_base64_string(path)
+        self.external_locations = external_locations or {}
         super().__init__(
             {
-                "filename": self.filename,
+                "path": self.path,
                 "base64_string": self.base64_string,
                 "binary": self.binary,
                 "suffix": self.suffix,
+                "mime_type": self.mime_type,
+                "external_locations": self.external_locations,
             }
         )
 
+    def __str__(self):
+        return "FileStore: self.path"
+
+    @property
+    def size(self) -> int:
+        return os.path.getsize(self.path)
+
+    def upload_google(self, refresh: bool = False) -> None:
+        genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+        google_info = genai.upload_file(self.path, mime_type=self.mime_type)
+        self.external_locations["google"] = google_info.to_dict()
+
     @classmethod
+    @remove_edsl_version
     def from_dict(cls, d):
-        return cls(d["filename"], d["binary"], d["suffix"], d["base64_string"])
+        # return cls(d["filename"], d["binary"], d["suffix"], d["base64_string"])
+        return cls(**d)
 
     def __repr__(self):
-        return f"FileStore(filename='{self.filename}', binary='{self.binary}', 'suffix'={self.suffix})"
+        return f"FileStore({self.path})"
 
-    def encode_file_to_base64_string(self, file_path):
+    def encode_file_to_base64_string(self, file_path: str):
         try:
             # Attempt to open the file in text mode
             with open(file_path, "r") as text_file:
@@ -56,14 +116,14 @@ class FileStore(Scenario):
 
         return base64_string
 
-    def open(self):
+    def open(self) -> "IO":
         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):
+    def base64_to_text_file(base64_string) -> "IO":
         # Decode the base64 string to bytes
         text_data_bytes = base64.b64decode(base64_string)
 
@@ -101,7 +161,9 @@ class FileStore(Scenario):
 
         # Create a named temporary file
         mode = "wb" if self.binary else "w"
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix, mode=mode)
+        temp_file = tempfile.NamedTemporaryFile(
+            delete=False, suffix="." + suffix, mode=mode
+        )
 
         if self.binary:
             temp_file.write(file_like_object.read())
@@ -112,23 +174,95 @@ class FileStore(Scenario):
 
         return temp_file.name
 
-    def push(self, description=None):
+    def view(self, max_size: int = 300) -> None:
+        if self.suffix == "pdf":
+            view_pdf(self.path)
+
+        if self.suffix == "png" or self.suffix == "jpg" or self.suffix == "jpeg":
+            if is_notebook():
+                from IPython.display import Image
+                from PIL import Image as PILImage
+
+                if max_size:
+                    # Open the image using Pillow
+                    with PILImage.open(self.path) as img:
+                        # Get original width and height
+                        original_width, original_height = img.size
+
+                        # Calculate the scaling factor
+                        scale = min(
+                            max_size / original_width, max_size / original_height
+                        )
+
+                        # Calculate new dimensions
+                        new_width = int(original_width * scale)
+                        new_height = int(original_height * scale)
+
+                        return Image(self.path, width=new_width, height=new_height)
+                else:
+                    return Image(self.path)
+
+    def push(
+        self, description: Optional[str] = None, visibility: str = "unlisted"
+    ) -> dict:
+        """
+        Push the object to Coop.
+        :param description: The description of the object to push.
+        :param visibility: The visibility of the object to push.
+        """
         scenario_version = Scenario.from_dict(self.to_dict())
         if description is None:
-            description = "File: " + self["filename"]
-        info = scenario_version.push(description=description)
+            description = "File: " + self.path
+        info = scenario_version.push(description=description, visibility=visibility)
         return info
 
     @classmethod
-    def pull(cls, uuid):
-        scenario_version = Scenario.pull(uuid)
+    def pull(cls, uuid: str, expected_parrot_url: Optional[str] = None) -> "FileStore":
+        """
+        :param uuid: The UUID of the object to pull.
+        :param expected_parrot_url: The URL of the Parrot server to use.
+        :return: The object pulled from the Parrot server.
+        """
+        scenario_version = Scenario.pull(uuid, expected_parrot_url=expected_parrot_url)
         return cls.from_dict(scenario_version.to_dict())
 
+    @classmethod
+    def from_url(
+        cls,
+        url: str,
+        download_path: Optional[str] = None,
+        mime_type: Optional[str] = None,
+    ) -> "FileStore":
+        """
+        :param url: The URL of the file to download.
+        :param download_path: The path to save the downloaded file.
+        :param mime_type: The MIME type of the file. If None, it will be guessed from the file extension.
+        """
+
+        response = requests.get(url, stream=True)
+        response.raise_for_status()  # Raises an HTTPError for bad responses
+
+        # Get the filename from the URL if download_path is not provided
+        if download_path is None:
+            filename = os.path.basename(urlparse(url).path)
+            if not filename:
+                filename = "downloaded_file"
+            # download_path = filename
+            download_path = os.path.join(os.getcwd(), filename)
+
+        # Ensure the directory exists
+        os.makedirs(os.path.dirname(download_path), exist_ok=True)
+
+        # Write the file
+        with open(download_path, "wb") as file:
+            for chunk in response.iter_content(chunk_size=8192):
+                file.write(chunk)
+
+        # Create and return a new File instance
+        return cls(download_path, mime_type=mime_type)
 
-class CSVFileStore(FileStore):
-    def __init__(self, filename):
-        super().__init__(filename, suffix=".csv")
 
+class CSVFileStore(FileStore):
     @classmethod
     def example(cls):
         from edsl.results.Results import Results
@@ -147,9 +281,6 @@ class CSVFileStore(FileStore):
 
 
 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
@@ -225,9 +356,6 @@ class PDFFileStore(FileStore):
 
 
 class PNGFileStore(FileStore):
-    def __init__(self, filename):
-        super().__init__(filename, suffix=".png")
-
     @classmethod
     def example(cls):
         import textwrap
@@ -251,9 +379,6 @@ class PNGFileStore(FileStore):
 
 
 class SQLiteFileStore(FileStore):
-    def __init__(self, filename):
-        super().__init__(filename, suffix=".sqlite")
-
     @classmethod
     def example(cls):
         import sqlite3
@@ -265,6 +390,8 @@ class SQLiteFileStore(FileStore):
             c.execute("""CREATE TABLE stocks (date text)""")
             conn.commit()
 
+            return cls(f.name)
+
     def view(self):
         import subprocess
         import os
@@ -273,6 +400,22 @@ class SQLiteFileStore(FileStore):
         os.system(f"sqlite3 {sqlite_path}")
 
 
+class HTMLFileStore(FileStore):
+    @classmethod
+    def example(cls):
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as f:
+            f.write("<html><body><h1>Test</h1></body></html>".encode())
+            return cls(f.name)
+
+    def view(self):
+        import webbrowser
+
+        html_path = self.to_tempfile()
+        webbrowser.open("file://" + html_path)
+
+
 if __name__ == "__main__":
     # file_path = "../conjure/examples/Ex11-2.sav"
     # fs = FileStore(file_path)
@@ -289,9 +432,10 @@ if __name__ == "__main__":
     # fs = PDFFileStore("paper.pdf")
     # fs.view()
     # from edsl import Conjure
-
-    fs = PNGFileStore("robot.png")
-    fs.view()
+    pass
+    # fs = PNGFileStore("logo.png")
+    # fs.view()
+    # fs.upload_google()
 
     # c = Conjure(datafile_name=fs.to_tempfile())
     # f = PDFFileStore("paper.pdf")

edsl/scenarios/Scenario.py

@@ -2,19 +2,18 @@
 
 from __future__ import annotations
 import copy
-import base64
 import hashlib
 import os
 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
 
 
-class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
+class Scenario(Base, UserDict, ScenarioHtmlMixin):
     """A Scenario is a dictionary of keys/values.
 
     They can be used parameterize edsl questions."""
@@ -42,16 +41,46 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
 
         return ScenarioList([copy.deepcopy(self) for _ in range(n)])
 
+    # @property
+    # def has_image(self) -> bool:
+    #     """Return whether the scenario has an image."""
+    #     if not hasattr(self, "_has_image"):
+    #         self._has_image = False
+    #     return self._has_image
+
     @property
-    def has_image(self) -> bool:
-        """Return whether the scenario has an image."""
-        if not hasattr(self, "_has_image"):
-            self._has_image = False
-        return self._has_image
+    def has_jinja_braces(self) -> bool:
+        """Return whether the scenario has jinja braces. This matters for rendering.
+
+        >>> s = Scenario({"food": "I love {{wood chips}}"})
+        >>> s.has_jinja_braces
+        True
+        """
+        for _, value in self.items():
+            if isinstance(value, str):
+                if "{{" in value and "}}" in value:
+                    return True
+        return False
 
-    @has_image.setter
-    def has_image(self, value):
-        self._has_image = value
+    def convert_jinja_braces(
+        self, replacement_left="<<", replacement_right=">>"
+    ) -> Scenario:
+        """Convert Jinja braces to some other character.
+
+        >>> s = Scenario({"food": "I love {{wood chips}}"})
+        >>> s.convert_jinja_braces()
+        Scenario({'food': 'I love <<wood chips>>'})
+
+        """
+        new_scenario = Scenario()
+        for key, value in self.items():
+            if isinstance(value, str):
+                new_scenario[key] = value.replace("{{", replacement_left).replace(
+                    "}}", replacement_right
+                )
+            else:
+                new_scenario[key] = value
+        return new_scenario
 
     def __add__(self, other_scenario: "Scenario") -> "Scenario":
         """Combine two scenarios by taking the union of their keys
@@ -75,8 +104,6 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
             data1 = copy.deepcopy(self.data)
             data2 = copy.deepcopy(other_scenario.data)
             s = Scenario(data1 | data2)
-            if self.has_image or other_scenario.has_image:
-                s._has_image = True
             return s
 
     def rename(self, replacement_dict: dict) -> "Scenario":
@@ -142,6 +169,7 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         print_json(json.dumps(self.to_dict()))
 
     def __repr__(self):
+        # return "Scenario(" + reprlib.repr(self.data) + ")"
         return "Scenario(" + repr(self.data) + ")"
 
     def _repr_html_(self):
@@ -196,26 +224,34 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         return cls({"url": url, field_name: text})
 
     @classmethod
-    def from_image(cls, image_path: str) -> str:
-        """Creates a scenario with a base64 encoding of an image.
+    def from_file(cls, file_path: str, field_name: str) -> "Scenario":
+        """Creates a scenario from a file."""
+        from edsl.scenarios.FileStore import FileStore
 
-        Example:
+        fs = FileStore(file_path)
+        return cls({field_name: fs})
 
-        >>> s = Scenario.from_image(Scenario.example_image())
-        >>> s
-        Scenario({'file_path': '...', 'encoded_image': '...'})
+    @classmethod
+    def from_image(
+        cls, image_path: str, image_name: Optional[str] = None
+    ) -> "Scenario":
         """
-        with open(image_path, "rb") as image_file:
-            s = cls(
-                {
-                    "file_path": image_path,
-                    "encoded_image": base64.b64encode(image_file.read()).decode(
-                        "utf-8"
-                    ),
-                }
-            )
-            s.has_image = True
-            return s
+        Creates a scenario with a base64 encoding of an image.
+
+        Args:
+            image_path (str): Path to the image file.
+
+        Returns:
+            Scenario: A new Scenario instance with image information.
+
+        """
+        if not os.path.exists(image_path):
+            raise FileNotFoundError(f"Image file not found: {image_path}")
+
+        if image_name is None:
+            image_name = os.path.basename(image_path).split(".")[0]
+
+        return cls.from_file(image_path, image_name)
 
     @classmethod
     def from_pdf(cls, pdf_path):
@@ -429,18 +465,21 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         return table
 
     @classmethod
-    def example(cls, randomize: bool = False) -> Scenario:
+    def example(cls, randomize: bool = False, has_image=False) -> Scenario:
         """
         Returns an example Scenario instance.
 
         :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": f"A reseacher studying whether LLMs can be used to generate surveys.{addition}",
-            }
-        )
+        if not has_image:
+            addition = "" if not randomize else str(uuid4())
+            return cls(
+                {
+                    "persona": f"A reseacher studying whether LLMs can be used to generate surveys.{addition}",
+                }
+            )
+        else:
+            return cls.from_image(cls.example_image())
 
     def code(self) -> List[str]:
         """Return the code for the scenario."""