PyPI - edsl - Versions diffs - 0.1.33.dev2__py3-none-any.whl → 0.1.33.dev3__py3-none-any.whl - Mend

edsl 0.1.33.dev2py3-none-any.whl → 0.1.33.dev3py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (63) hide show

edsl/Base.py +9 -3
edsl/__init__.py +1 -0
edsl/__version__.py +1 -1
edsl/agents/Agent.py +6 -6
edsl/agents/Invigilator.py +6 -3
edsl/agents/InvigilatorBase.py +8 -27
edsl/agents/{PromptConstructionMixin.py → PromptConstructor.py} +101 -29
edsl/config.py +26 -34
edsl/coop/coop.py +11 -2
edsl/data_transfer_models.py +27 -73
edsl/enums.py +2 -0
edsl/inference_services/GoogleService.py +1 -1
edsl/inference_services/InferenceServiceABC.py +44 -13
edsl/inference_services/OpenAIService.py +7 -4
edsl/inference_services/TestService.py +24 -15
edsl/inference_services/TogetherAIService.py +170 -0
edsl/inference_services/registry.py +2 -0
edsl/jobs/Jobs.py +18 -8
edsl/jobs/buckets/BucketCollection.py +24 -15
edsl/jobs/buckets/TokenBucket.py +64 -10
edsl/jobs/interviews/Interview.py +115 -47
edsl/jobs/interviews/{interview_exception_tracking.py → InterviewExceptionCollection.py} +16 -0
edsl/jobs/interviews/InterviewExceptionEntry.py +2 -0
edsl/jobs/runners/JobsRunnerAsyncio.py +86 -161
edsl/jobs/runners/JobsRunnerStatus.py +331 -0
edsl/jobs/tasks/TaskHistory.py +17 -0
edsl/language_models/LanguageModel.py +26 -31
edsl/language_models/registry.py +13 -9
edsl/questions/QuestionBase.py +64 -16
edsl/questions/QuestionBudget.py +93 -41
edsl/questions/QuestionFreeText.py +6 -0
edsl/questions/QuestionMultipleChoice.py +11 -26
edsl/questions/QuestionNumerical.py +5 -4
edsl/questions/Quick.py +41 -0
edsl/questions/ResponseValidatorABC.py +6 -5
edsl/questions/derived/QuestionLinearScale.py +4 -1
edsl/questions/derived/QuestionTopK.py +4 -1
edsl/questions/derived/QuestionYesNo.py +8 -2
edsl/questions/templates/budget/__init__.py +0 -0
edsl/questions/templates/budget/answering_instructions.jinja +7 -0
edsl/questions/templates/budget/question_presentation.jinja +7 -0
edsl/questions/templates/extract/__init__.py +0 -0
edsl/questions/templates/rank/__init__.py +0 -0
edsl/results/DatasetExportMixin.py +5 -1
edsl/results/Result.py +1 -1
edsl/results/Results.py +4 -1
edsl/scenarios/FileStore.py +71 -10
edsl/scenarios/Scenario.py +86 -21
edsl/scenarios/ScenarioImageMixin.py +2 -2
edsl/scenarios/ScenarioList.py +13 -0
edsl/scenarios/ScenarioListPdfMixin.py +150 -4
edsl/study/Study.py +32 -0
edsl/surveys/Rule.py +10 -1
edsl/surveys/RuleCollection.py +19 -3
edsl/surveys/Survey.py +7 -0
edsl/templates/error_reporting/interview_details.html +6 -1
edsl/utilities/utilities.py +9 -1
{edsl-0.1.33.dev2.dist-info → edsl-0.1.33.dev3.dist-info}/METADATA +2 -1
{edsl-0.1.33.dev2.dist-info → edsl-0.1.33.dev3.dist-info}/RECORD +61 -55
edsl/jobs/interviews/retry_management.py +0 -39
edsl/jobs/runners/JobsRunnerStatusMixin.py +0 -333
{edsl-0.1.33.dev2.dist-info → edsl-0.1.33.dev3.dist-info}/LICENSE +0 -0
{edsl-0.1.33.dev2.dist-info → edsl-0.1.33.dev3.dist-info}/WHEEL +0 -0

edsl/scenarios/FileStore.py CHANGED Viewed

@@ -120,14 +120,22 @@ class FileStore(Scenario):
         return info
     @classmethod
-    def pull(cls, uuid):
-        scenario_version = Scenario.pull(uuid)
+    def pull(cls, uuid, expected_parrot_url: Optional[str] = None):
+        scenario_version = Scenario.pull(uuid, expected_parrot_url=expected_parrot_url)
         return cls.from_dict(scenario_version.to_dict())
 class CSVFileStore(FileStore):
-    def __init__(self, filename):
-        super().__init__(filename, suffix=".csv")
+    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):
@@ -147,8 +155,16 @@ class CSVFileStore(FileStore):
 class PDFFileStore(FileStore):
-    def __init__(self, filename):
-        super().__init__(filename, suffix=".pdf")
+    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()
@@ -225,8 +241,16 @@ class PDFFileStore(FileStore):
 class PNGFileStore(FileStore):
-    def __init__(self, filename):
-        super().__init__(filename, suffix=".png")
+    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):
@@ -251,8 +275,16 @@ class PNGFileStore(FileStore):
 class SQLiteFileStore(FileStore):
-    def __init__(self, filename):
-        super().__init__(filename, suffix=".sqlite")
+    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):
@@ -265,6 +297,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 +307,33 @@ class SQLiteFileStore(FileStore):
         os.system(f"sqlite3 {sqlite_path}")
+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):
+        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)

edsl/scenarios/Scenario.py CHANGED Viewed

@@ -5,6 +5,10 @@ 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
@@ -13,6 +17,8 @@ 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):
     """A Scenario is a dictionary of keys/values.
@@ -49,6 +55,39 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
             self._has_image = False
         return self._has_image
+    @property
+    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 key, value in self.items():
+            if "{{" in str(value) and "}}" in value:
+                return True
+        return False
+    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
     @has_image.setter
     def has_image(self, value):
         self._has_image = value
@@ -142,6 +181,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 +236,48 @@ 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_image(
+        cls, image_path: str, image_name: Optional[str] = None
+    ) -> "Scenario":
+        """
+        Creates a scenario with a base64 encoding of an image.
-        Example:
+        Args:
+            image_path (str): Path to the image file.
+        Returns:
+            Scenario: A new Scenario instance with image information.
+        Example:
         >>> s = Scenario.from_image(Scenario.example_image())
         >>> s
-        Scenario({'file_path': '...', 'encoded_image': '...'})
+        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:
-            s = cls(
-                {
-                    "file_path": image_path,
-                    "encoded_image": base64.b64encode(image_file.read()).decode(
-                        "utf-8"
-                    ),
-                }
-            )
-            s.has_image = True
-            return s
+            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
     @classmethod
     def from_pdf(cls, pdf_path):
@@ -429,18 +491,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."""

edsl/scenarios/ScenarioImageMixin.py CHANGED Viewed

@@ -13,7 +13,7 @@ class ScenarioImageMixin:
         >>> from edsl.scenarios.Scenario import Scenario
         >>> s = Scenario({"food": "wood chips"})
         >>> s.add_image(Scenario.example_image())
-        Scenario({'food': 'wood chips', 'file_path': '...', 'encoded_image': '...'})
+        Scenario({'food': 'wood chips', 'logo': ...})
         """
         new_scenario = self.from_image(image_path)
         return self + new_scenario
@@ -33,7 +33,7 @@ class ScenarioImageMixin:
         >>> from edsl.scenarios.Scenario import Scenario
         >>> s = Scenario.from_image(Scenario.example_image())
         >>> s
-        Scenario({'file_path': '...', 'encoded_image': '...'})
+        Scenario({'logo': ...})
         """
         if image_path.startswith("http://") or image_path.startswith("https://"):

edsl/scenarios/ScenarioList.py CHANGED Viewed

@@ -39,6 +39,15 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
             super().__init__([])
         self.codebook = codebook or {}
+    @property
+    def has_jinja_braces(self) -> bool:
+        """Check if the ScenarioList has Jinja braces."""
+        return any([scenario.has_jinja_braces for scenario in self])
+    def convert_jinja_braces(self) -> ScenarioList:
+        """Convert Jinja braces to Python braces."""
+        return ScenarioList([scenario.convert_jinja_braces() for scenario in self])
     def give_valid_names(self) -> ScenarioList:
         """Give valid names to the scenario keys.
@@ -273,6 +282,10 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         for s in data["scenarios"]:
             _ = s.pop("edsl_version")
             _ = s.pop("edsl_class_name")
+        for scenario in data["scenarios"]:
+            for key, value in scenario.items():
+                if hasattr(value, "to_dict"):
+                    data[key] = value.to_dict()
         return data_to_html(data)
     def tally(self, field) -> dict:

edsl/scenarios/ScenarioListPdfMixin.py CHANGED Viewed

@@ -1,15 +1,161 @@
 import fitz  # PyMuPDF
 import os
+import copy
 import subprocess
+import requests
+import tempfile
+import os
+# import urllib.parse as urlparse
+from urllib.parse import urlparse
 # from edsl import Scenario
+import requests
+import re
+import tempfile
+import os
+import atexit
+from urllib.parse import urlparse, parse_qs
+class GoogleDriveDownloader:
+    _temp_dir = None
+    _temp_file_path = None
+    @classmethod
+    def fetch_from_drive(cls, url, filename=None):
+        # Extract file ID from the URL
+        file_id = cls._extract_file_id(url)
+        if not file_id:
+            raise ValueError("Invalid Google Drive URL")
+        # Construct the download URL
+        download_url = f"https://drive.google.com/uc?export=download&id={file_id}"
+        # Send a GET request to the URL
+        session = requests.Session()
+        response = session.get(download_url, stream=True)
+        response.raise_for_status()
+        # Check for large file download prompt
+        for key, value in response.cookies.items():
+            if key.startswith("download_warning"):
+                params = {"id": file_id, "confirm": value}
+                response = session.get(download_url, params=params, stream=True)
+                break
+        # Create a temporary file to save the download
+        if not filename:
+            filename = "downloaded_file"
+        if cls._temp_dir is None:
+            cls._temp_dir = tempfile.TemporaryDirectory()
+            atexit.register(cls._cleanup)
+        cls._temp_file_path = os.path.join(cls._temp_dir.name, filename)
+        # Write the content to the temporary file
+        with open(cls._temp_file_path, "wb") as f:
+            for chunk in response.iter_content(32768):
+                if chunk:
+                    f.write(chunk)
+        print(f"File saved to: {cls._temp_file_path}")
+        return cls._temp_file_path
+    @staticmethod
+    def _extract_file_id(url):
+        # Try to extract file ID from '/file/d/' format
+        file_id_match = re.search(r"/d/([a-zA-Z0-9-_]+)", url)
+        if file_id_match:
+            return file_id_match.group(1)
+        # If not found, try to extract from 'open?id=' format
+        parsed_url = urlparse(url)
+        query_params = parse_qs(parsed_url.query)
+        if "id" in query_params:
+            return query_params["id"][0]
+        return None
+    @classmethod
+    def _cleanup(cls):
+        if cls._temp_dir:
+            cls._temp_dir.cleanup()
+    @classmethod
+    def get_temp_file_path(cls):
+        return cls._temp_file_path
+def fetch_and_save_pdf(url, filename):
+    # Send a GET request to the URL
+    response = requests.get(url)
+    # Check if the request was successful
+    response.raise_for_status()
+    # Create a temporary directory
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Construct the full path for the file
+        temp_file_path = os.path.join(temp_dir, filename)
+        # Write the content to the temporary file
+        with open(temp_file_path, "wb") as file:
+            file.write(response.content)
+        print(f"PDF saved to: {temp_file_path}")
+        # Here you can perform operations with the file
+        # The file will be automatically deleted when you exit this block
+    return temp_file_path
+# Example usage:
+# url = "https://example.com/sample.pdf"
+# fetch_and_save_pdf(url, "sample.pdf")
 class ScenarioListPdfMixin:
     @classmethod
-    def from_pdf(cls, filename):
-        scenarios = list(cls.extract_text_from_pdf(filename))
-        return cls(scenarios)
+    def from_pdf(cls, filename_or_url, collapse_pages=False):
+        # Check if the input is a URL
+        if cls.is_url(filename_or_url):
+            # Check if it's a Google Drive URL
+            if "drive.google.com" in filename_or_url:
+                temp_filename = GoogleDriveDownloader.fetch_from_drive(
+                    filename_or_url, "temp_pdf.pdf"
+                )
+            else:
+                # For other URLs, use the previous fetch_and_save_pdf function
+                temp_filename = fetch_and_save_pdf(filename_or_url, "temp_pdf.pdf")
+            scenarios = list(cls.extract_text_from_pdf(temp_filename))
+        else:
+            # If it's not a URL, assume it's a local file path
+            scenarios = list(cls.extract_text_from_pdf(filename_or_url))
+        if not collapse_pages:
+            return cls(scenarios)
+        else:
+            txt = ""
+            for scenario in scenarios:
+                txt += scenario["text"]
+            from edsl.scenarios import Scenario
+            base_scenario = copy.copy(scenarios[0])
+            base_scenario["text"] = txt
+        return base_scenario
+    @staticmethod
+    def is_url(string):
+        try:
+            result = urlparse(string)
+            return all([result.scheme, result.netloc])
+        except ValueError:
+            return False
     @classmethod
     def _from_pdf_to_image(cls, pdf_path, image_format="jpeg"):
@@ -38,7 +184,7 @@ class ScenarioListPdfMixin:
                 scenario = Scenario._from_filepath_image(image_path)
                 scenarios.append(scenario)
-            print(f"Saved {len(images)} pages as images in {output_folder}")
+            # print(f"Saved {len(images)} pages as images in {output_folder}")
             return cls(scenarios)
     @staticmethod

edsl/study/Study.py CHANGED Viewed

@@ -469,6 +469,38 @@ class Study:
         coop = Coop()
         return coop.create(self, description=self.description)
+    def delete_object(self, identifier: Union[str, UUID]):
+        """
+        Delete an EDSL object from the study.
+        :param identifier: Either the variable name or the hash of the object to delete
+        :raises ValueError: If the object is not found in the study
+        """
+        if isinstance(identifier, str):
+            # If identifier is a variable name or a string representation of UUID
+            for hash, obj_entry in list(self.objects.items()):
+                if obj_entry.variable_name == identifier or hash == identifier:
+                    del self.objects[hash]
+                    self._create_mapping_dicts()  # Update internal mappings
+                    if self.verbose:
+                        print(f"Deleted object with identifier: {identifier}")
+                    return
+            raise ValueError(f"No object found with identifier: {identifier}")
+        elif isinstance(identifier, UUID):
+            # If identifier is a UUID object
+            hash_str = str(identifier)
+            if hash_str in self.objects:
+                del self.objects[hash_str]
+                self._create_mapping_dicts()  # Update internal mappings
+                if self.verbose:
+                    print(f"Deleted object with hash: {hash_str}")
+                return
+            raise ValueError(f"No object found with hash: {hash_str}")
+        else:
+            raise TypeError(
+                "Identifier must be either a string (variable name or hash) or a UUID object"
+            )
     @classmethod
     def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
         """Pull the object from coop."""

edsl/surveys/Rule.py CHANGED Viewed

@@ -18,6 +18,7 @@ with a low (-1) priority.
 """
 import ast
+import random
 from typing import Any, Union, List
 from jinja2 import Template
@@ -254,8 +255,16 @@ class Rule:
             msg = f"""Exception in evaluation: {e}. The expression is: {self.expression}. The current info env trying to substitute in is: {current_info_env}. After the substition, the expression was: {to_evaluate}."""
             raise SurveyRuleCannotEvaluateError(msg)
+        random_functions = {
+            "randint": random.randint,
+            "choice": random.choice,
+            "random": random.random,
+            "uniform": random.uniform,
+            # Add any other random functions you want to allow
+        }
         try:
-            return EvalWithCompoundTypes().eval(to_evaluate)
+            return EvalWithCompoundTypes(functions=random_functions).eval(to_evaluate)
         except Exception as e:
             msg = f"""Exception in evaluation: {e}. The expression is: {self.expression}. The current info env trying to substitute in is: {current_info_env}. After the substition, the expression was: {to_evaluate}."""
             raise SurveyRuleCannotEvaluateError(msg)

edsl/surveys/RuleCollection.py CHANGED Viewed

@@ -172,7 +172,8 @@ class RuleCollection(UserList):
     def next_question(self, q_now: int, answers: dict[str, Any]) -> NextQuestion:
         """Find the next question by index, given the rule collection.
-        This rule is applied after the question is asked.
+        This rule is applied after the question is answered.
         :param q_now: The current question index.
         :param answers: The answers to the survey questions so far, including the current question.
@@ -182,8 +183,17 @@ class RuleCollection(UserList):
         NextQuestion(next_q=3, num_rules_found=2, expressions_evaluating_to_true=1, priority=1)
         """
-        # What rules apply at the current node?
+        # # is this the first question? If it is, we need to check if it should be skipped.
+        # if q_now == 0:
+        #     if self.skip_question_before_running(q_now, answers):
+        #         return NextQuestion(
+        #             next_q=q_now + 1,
+        #             num_rules_found=0,
+        #             expressions_evaluating_to_true=0,
+        #             priority=-1,
+        #         )
+        # breakpoint()
         expressions_evaluating_to_true = 0
         next_q = None
         highest_priority = -2  # start with -2 to 'pick up' the default rule added
@@ -205,6 +215,12 @@ class RuleCollection(UserList):
                 f"No rules found for question {q_now}"
             )
+        # breakpoint()
+        ## Now we need to check if the *next question* has any 'before; rules that we should follow
+        for rule in self.applicable_rules(next_q, before_rule=True):
+            if rule.evaluate(answers):  # rule evaluates to True
+                return self.next_question(next_q, answers)
         return NextQuestion(
             next_q, num_rules_found, expressions_evaluating_to_true, highest_priority
         )

edsl/surveys/Survey.py CHANGED Viewed

@@ -866,6 +866,7 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
     def clear_non_default_rules(self) -> Survey:
         """Remove all non-default rules from the survey.
         >>> Survey.example().show_rules()
         ┏━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━┓
         ┃ current_q ┃ expression  ┃ next_q ┃ priority ┃ before_rule ┃
@@ -1173,9 +1174,15 @@ class Survey(SurveyExportMixin, SurveyFlowVisualizationMixin, Base):
         Question('multiple_choice', question_name = \"""q0\""", question_text = \"""Do you like school?\""", question_options = ['yes', 'no'])
         >>> i2.send({"q0": "no"})
         Question('multiple_choice', question_name = \"""q1\""", question_text = \"""Why not?\""", question_options = ['killer bees in cafeteria', 'other'])
         """
         self.answers = {}
         question = self._questions[0]
+        # should the first question be skipped?
+        if self.rule_collection.skip_question_before_running(0, self.answers):
+            question = self.next_question(question, self.answers)
         while not question == EndOfSurvey:
             # breakpoint()
             answer = yield question

edsl/templates/error_reporting/interview_details.html CHANGED Viewed

@@ -31,7 +31,12 @@
             <tr>
                 <td>Human-readable question</td>
-                <td>{{ interview.survey.get_question(question).html(scenario = interview.scenario, agent = interview.agent) }}</td>
+                <td>{{ interview.survey.get_question(question).html(
+                    scenario = interview.scenario,
+                    agent = interview.agent,
+                    answers = exception_message.answers)
+                }}</td>
             </tr>
             <tr>
                 <td>Scenario</td>

edsl/utilities/utilities.py CHANGED Viewed

@@ -20,6 +20,14 @@ from html import escape
 from typing import Callable, Union
+class CustomEncoder(json.JSONEncoder):
+    def default(self, obj):
+        try:
+            return json.JSONEncoder.default(self, obj)
+        except TypeError:
+            return str(obj)
 def time_it(func):
     @wraps(func)
     def wrapper(*args, **kwargs):
@@ -124,7 +132,7 @@ def data_to_html(data, replace_new_lines=False):
     from pygments.formatters import HtmlFormatter
     from IPython.display import HTML
-    json_str = json.dumps(data, indent=4)
+    json_str = json.dumps(data, indent=4, cls=CustomEncoder)
     formatted_json = highlight(
         json_str,
         JsonLexer(),

edsl 0.1.33.dev2__py3-none-any.whl → 0.1.33.dev3__py3-none-any.whl

edsl 0.1.33.dev2py3-none-any.whl → 0.1.33.dev3py3-none-any.whl