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

edsl/scenarios/Scenario.py

@@ -5,10 +5,6 @@ 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
@@ -17,8 +13,6 @@ 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.
@@ -55,39 +49,6 @@ 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
@@ -181,7 +142,6 @@ 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):
@@ -236,48 +196,26 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         return cls({"url": url, field_name: text})
 
     @classmethod
-    def from_image(
-        cls, image_path: str, image_name: Optional[str] = None
-    ) -> "Scenario":
-        """
-        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.
+    def from_image(cls, image_path: str) -> str:
+        """Creates a scenario with a base64 encoding of an image.
 
         Example:
+
         >>> s = Scenario.from_image(Scenario.example_image())
         >>> s
-        Scenario({'logo': ...})
+        Scenario({'file_path': '...', 'encoded_image': '...'})
         """
-        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
+            s = cls(
+                {
+                    "file_path": image_path,
+                    "encoded_image": base64.b64encode(image_file.read()).decode(
+                        "utf-8"
+                    ),
+                }
+            )
+            s.has_image = True
+            return s
 
     @classmethod
     def from_pdf(cls, pdf_path):
@@ -491,21 +429,18 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         return table
 
     @classmethod
-    def example(cls, randomize: bool = False, has_image=False) -> Scenario:
+    def example(cls, randomize: bool = False) -> Scenario:
         """
         Returns an example Scenario instance.
 
         :param randomize: If True, adds a random string to the value of the example key.
         """
-        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())
+        addition = "" if not randomize else str(uuid4())
+        return cls(
+            {
+                "persona": f"A reseacher studying whether LLMs can be used to generate surveys.{addition}",
+            }
+        )
 
     def code(self) -> List[str]:
         """Return the code for the scenario."""

edsl/scenarios/ScenarioImageMixin.py

@@ -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', 'logo': ...})
+        Scenario({'food': 'wood chips', 'file_path': '...', 'encoded_image': '...'})
         """
         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({'logo': ...})
+        Scenario({'file_path': '...', 'encoded_image': '...'})
         """
 
         if image_path.startswith("http://") or image_path.startswith("https://"):

edsl/scenarios/ScenarioList.py

@@ -39,15 +39,6 @@ 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.
 
@@ -282,10 +273,6 @@ 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

@@ -1,161 +1,15 @@
 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_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
+    def from_pdf(cls, filename):
+        scenarios = list(cls.extract_text_from_pdf(filename))
+        return cls(scenarios)
 
     @classmethod
     def _from_pdf_to_image(cls, pdf_path, image_format="jpeg"):
@@ -184,7 +38,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

@@ -469,38 +469,6 @@ 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

@@ -18,7 +18,6 @@ with a low (-1) priority.
 """
 
 import ast
-import random
 from typing import Any, Union, List
 
 from jinja2 import Template
@@ -255,16 +254,8 @@ 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(functions=random_functions).eval(to_evaluate)
+            return EvalWithCompoundTypes().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

@@ -172,8 +172,7 @@ 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 answered.
+        This rule is applied after the question is asked.
 
         :param q_now: The current question index.
         :param answers: The answers to the survey questions so far, including the current question.
@@ -183,17 +182,8 @@ class RuleCollection(UserList):
         NextQuestion(next_q=3, num_rules_found=2, expressions_evaluating_to_true=1, priority=1)
 
         """
-        # # 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()
+        # What rules apply at the current node?
+
         expressions_evaluating_to_true = 0
         next_q = None
         highest_priority = -2  # start with -2 to 'pick up' the default rule added
@@ -215,12 +205,6 @@ 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

@@ -866,7 +866,6 @@ 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 ┃
@@ -1174,15 +1173,9 @@ 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

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

edsl/utilities/utilities.py

@@ -20,14 +20,6 @@ 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):
@@ -132,7 +124,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, cls=CustomEncoder)
+    json_str = json.dumps(data, indent=4)
     formatted_json = highlight(
         json_str,
         JsonLexer(),

{edsl-0.1.33.dist-info → edsl-0.1.33.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.33
+Version: 0.1.33.dev2
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT
@@ -45,7 +45,6 @@ Requires-Dist: setuptools (<72.0)
 Requires-Dist: simpleeval (>=0.9.13,<0.10.0)
 Requires-Dist: sqlalchemy (>=2.0.23,<3.0.0)
 Requires-Dist: tenacity (>=8.2.3,<9.0.0)
-Requires-Dist: urllib3 (>=1.25.4,<1.27)
 Project-URL: Documentation, https://docs.expectedparrot.com
 Description-Content-Type: text/markdown