edsl 0.1.33.dev3__py3-none-any.whl → 0.1.34.dev1__py3-none-any.whl

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/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/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,30 +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, expected_parrot_url: Optional[str] = None):
+    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,
-        binary: Optional[bool] = None,
-        suffix: Optional[str] = None,
-        base64_string: Optional[str] = None,
-    ):
-        super().__init__(
-            filename, binary=binary, base64_string=base64_string, suffix=".csv"
-        )
 
     @classmethod
     def example(cls):
@@ -155,16 +282,6 @@ class CSVFileStore(FileStore):
 
 
 class PDFFileStore(FileStore):
-    def __init__(
-        self,
-        filename,
-        binary: Optional[bool] = None,
-        suffix: Optional[str] = None,
-        base64_string: Optional[str] = None,
-    ):
-        super().__init__(
-            filename, binary=binary, base64_string=base64_string, suffix=".pdf"
-        )
 
     def view(self):
         pdf_path = self.to_tempfile()
@@ -241,16 +358,6 @@ class PDFFileStore(FileStore):
 
 
 class PNGFileStore(FileStore):
-    def __init__(
-        self,
-        filename,
-        binary: Optional[bool] = None,
-        suffix: Optional[str] = None,
-        base64_string: Optional[str] = None,
-    ):
-        super().__init__(
-            filename, binary=binary, base64_string=base64_string, suffix=".png"
-        )
 
     @classmethod
     def example(cls):
@@ -275,16 +382,6 @@ class PNGFileStore(FileStore):
 
 
 class SQLiteFileStore(FileStore):
-    def __init__(
-        self,
-        filename,
-        binary: Optional[bool] = None,
-        suffix: Optional[str] = None,
-        base64_string: Optional[str] = None,
-    ):
-        super().__init__(
-            filename, binary=binary, base64_string=base64_string, suffix=".sqlite"
-        )
 
     @classmethod
     def example(cls):
@@ -308,16 +405,6 @@ class SQLiteFileStore(FileStore):
 
 
 class HTMLFileStore(FileStore):
-    def __init__(
-        self,
-        filename,
-        binary: Optional[bool] = None,
-        suffix: Optional[str] = None,
-        base64_string: Optional[str] = None,
-    ):
-        super().__init__(
-            filename, binary=binary, base64_string=base64_string, suffix=".html"
-        )
 
     @classmethod
     def example(cls):
@@ -350,9 +437,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,25 +2,18 @@
 
 from __future__ import annotations
 import copy
-import base64
 import hashlib
 import os
-import reprlib
-import imghdr
-
-
 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.data_transfer_models import ImageInfo
-
 
-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."""
@@ -48,12 +41,12 @@ 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
 
     @property
     def has_jinja_braces(self) -> bool:
@@ -63,9 +56,10 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         >>> s.has_jinja_braces
         True
         """
-        for key, value in self.items():
-            if "{{" in str(value) and "}}" in value:
-                return True
+        for _, value in self.items():
+            if isinstance(value, str):
+                if "{{" in value and "}}" in value:
+                    return True
         return False
 
     def convert_jinja_braces(
@@ -88,10 +82,6 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
                 new_scenario[key] = value
         return new_scenario
 
-    @has_image.setter
-    def has_image(self, value):
-        self._has_image = value
-
     def __add__(self, other_scenario: "Scenario") -> "Scenario":
         """Combine two scenarios by taking the union of their keys
 
@@ -114,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":
@@ -235,6 +223,14 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         text = requests.get(url).text
         return cls({"url": url, field_name: text})
 
+    @classmethod
+    def from_file(cls, file_path: str, field_name: str) -> "Scenario":
+        """Creates a scenario from a file."""
+        from edsl.scenarios.FileStore import FileStore
+
+        fs = FileStore(file_path)
+        return cls({field_name: fs})
+
     @classmethod
     def from_image(
         cls, image_path: str, image_name: Optional[str] = None
@@ -248,36 +244,14 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         Returns:
             Scenario: A new Scenario instance with image information.
 
-        Example:
-        >>> s = Scenario.from_image(Scenario.example_image())
-        >>> s
-        Scenario({'logo': ...})
         """
         if not os.path.exists(image_path):
             raise FileNotFoundError(f"Image file not found: {image_path}")
 
-        with open(image_path, "rb") as image_file:
-            file_content = image_file.read()
-
-        file_name = os.path.basename(image_path)
-        file_size = os.path.getsize(image_path)
-        image_format = imghdr.what(image_path) or "unknown"
-
         if image_name is None:
-            image_name = file_name.split(".")[0]
-
-        image_info = ImageInfo(
-            file_path=image_path,
-            file_name=file_name,
-            image_format=image_format,
-            file_size=file_size,
-            encoded_image=base64.b64encode(file_content).decode("utf-8"),
-        )
-
-        scenario_data = {image_name: image_info}
-        s = cls(scenario_data)
-        s.has_image = True
-        return s
+            image_name = os.path.basename(image_path).split(".")[0]
+
+        return cls.from_file(image_path, image_name)
 
     @classmethod
     def from_pdf(cls, pdf_path):

edsl/scenarios/ScenarioList.py

@@ -530,7 +530,9 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         return ScenarioList([scenario.drop(fields) for scenario in self.data])
 
     @classmethod
-    def from_list(cls, name, values) -> ScenarioList:
+    def from_list(
+        cls, name: str, values: list, func: Optional[Callable] = None
+    ) -> ScenarioList:
         """Create a ScenarioList from a list of values.
 
         Example:
@@ -538,7 +540,9 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         >>> ScenarioList.from_list('name', ['Alice', 'Bob'])
         ScenarioList([Scenario({'name': 'Alice'}), Scenario({'name': 'Bob'})])
         """
-        return cls([Scenario({name: value}) for value in values])
+        if not func:
+            func = lambda x: x
+        return cls([Scenario({name: func(value)}) for value in values])
 
     def to_dataset(self) -> "Dataset":
         """

edsl/surveys/DAG.py

@@ -11,6 +11,7 @@ class DAG(UserDict):
         """Initialize the DAG class."""
         super().__init__(data)
         self.reverse_mapping = self._create_reverse_mapping()
+        self.validate_no_cycles()
 
     def _create_reverse_mapping(self):
         """
@@ -73,12 +74,73 @@ class DAG(UserDict):
         # else:
         #     return DAG(d)
 
+    def remove_node(self, node: int) -> None:
+        """Remove a node and all its connections from the DAG."""
+        self.pop(node, None)
+        for connections in self.values():
+            connections.discard(node)
+        # Adjust remaining nodes if necessary
+        self._adjust_nodes_after_removal(node)
+
+    def _adjust_nodes_after_removal(self, removed_node: int) -> None:
+        """Adjust node indices after a node is removed."""
+        new_dag = {}
+        for node, connections in self.items():
+            new_node = node if node < removed_node else node - 1
+            new_connections = {c if c < removed_node else c - 1 for c in connections}
+            new_dag[new_node] = new_connections
+        self.clear()
+        self.update(new_dag)
+
     @classmethod
     def example(cls):
         """Return an example of the `DAG`."""
         data = {"a": ["b", "c"], "b": ["d"], "c": [], "d": []}
         return cls(data)
 
+    def detect_cycles(self):
+        """
+        Detect cycles in the DAG using depth-first search.
+
+        :return: A list of cycles if any are found, otherwise an empty list.
+        """
+        visited = set()
+        path = []
+        cycles = []
+
+        def dfs(node):
+            if node in path:
+                cycle = path[path.index(node) :]
+                cycles.append(cycle + [node])
+                return
+
+            if node in visited:
+                return
+
+            visited.add(node)
+            path.append(node)
+
+            for child in self.get(node, []):
+                dfs(child)
+
+            path.pop()
+
+        for node in self:
+            if node not in visited:
+                dfs(node)
+
+        return cycles
+
+    def validate_no_cycles(self):
+        """
+        Validate that the DAG does not contain any cycles.
+
+        :raises ValueError: If cycles are detected in the DAG.
+        """
+        cycles = self.detect_cycles()
+        if cycles:
+            raise ValueError(f"Cycles detected in the DAG: {cycles}")
+
 
 if __name__ == "__main__":
     import doctest

edsl/surveys/MemoryPlan.py

@@ -211,6 +211,32 @@ class MemoryPlan(UserDict):
         mp.add_single_memory("q1", "q0")
         return mp
 
+    def remove_question(self, question_name: str) -> None:
+        """Remove a question from the memory plan.
+
+        :param question_name: The name of the question to remove.
+        """
+        self._check_valid_question_name(question_name)
+
+        # Remove the question from survey_question_names and question_texts
+        index = self.survey_question_names.index(question_name)
+        self.survey_question_names.pop(index)
+        self.question_texts.pop(index)
+
+        # Remove the question from the memory plan if it's a focal question
+        self.pop(question_name, None)
+
+        # Remove the question from all memories where it appears as a prior question
+        for focal_question, memory in self.items():
+            memory.remove_prior_question(question_name)
+
+        # Update the DAG
+        self.dag.remove_node(index)
+
+    def remove_prior_question(self, question_name: str) -> None:
+        """Remove a prior question from the memory."""
+        self.prior_questions = [q for q in self.prior_questions if q != question_name]
+
 
 if __name__ == "__main__":
     import doctest