edsl 0.1.31.dev4__py3-none-any.whl → 0.1.33__py3-none-any.whl

edsl/scenarios/ScenarioListExportMixin.py

@@ -20,13 +20,33 @@ def to_dataset(func):
     return wrapper
 
 
-def decorate_all_methods(cls):
-    for attr_name, attr_value in cls.__dict__.items():
-        if callable(attr_value):
+def decorate_methods_from_mixin(cls, mixin_cls):
+    for attr_name, attr_value in mixin_cls.__dict__.items():
+        if callable(attr_value) and not attr_name.startswith("__"):
             setattr(cls, attr_name, to_dataset(attr_value))
     return cls
 
 
-@decorate_all_methods
+# def decorate_all_methods(cls):
+#     for attr_name, attr_value in cls.__dict__.items():
+#         if callable(attr_value):
+#             setattr(cls, attr_name, to_dataset(attr_value))
+#     return cls
+
+
+# @decorate_all_methods
 class ScenarioListExportMixin(DatasetExportMixin):
     """Mixin class for exporting Results objects."""
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        decorate_methods_from_mixin(cls, DatasetExportMixin)
+
+    def to_docx(self, filename: str):
+        """Export the ScenarioList to a .docx file."""
+        dataset = self.to_dataset()
+        from edsl.results.DatasetTree import Tree
+
+        tree = Tree(dataset)
+        tree.construct_tree()
+        tree.to_docx(filename)

edsl/scenarios/ScenarioListPdfMixin.py

@@ -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,11 +184,14 @@ 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
     def extract_text_from_pdf(pdf_path):
+        from edsl import Scenario
+
+        # TODO: Add test case
         # Ensure the file exists
         if not os.path.exists(pdf_path):
             raise FileNotFoundError(f"The file {pdf_path} does not exist.")

edsl/study/SnapShot.py

@@ -57,10 +57,17 @@ class SnapShot:
         from edsl.Base import Base
         from edsl.study.Study import Study
 
+        def is_edsl_object(obj):
+            package_name = "edsl"
+            cls = obj.__class__
+            module_name = cls.__module__
+            return module_name.startswith(package_name)
+
         for name, value in namespace.items():
             # TODO check this code logic (if there are other objects with to_dict method that are not from edsl)
             if (
-                hasattr(value, "to_dict")
+                is_edsl_object(value)
+                and hasattr(value, "to_dict")
                 and not inspect.isclass(value)
                 and value.__class__ not in [o.__class__ for o in self.exclude]
             ):

edsl/study/Study.py

@@ -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

@@ -18,6 +18,7 @@ with a low (-1) priority.
 """
 
 import ast
+import random
 from typing import Any, Union, List
 
 from jinja2 import Template
@@ -117,13 +118,15 @@ class Rule:
     def _checks(self):
         pass
 
-    @add_edsl_version
+    # def _to_dict(self):
+
+    # @add_edsl_version
     def to_dict(self):
         """Convert the rule to a dictionary for serialization.
 
         >>> r = Rule.example()
         >>> r.to_dict()
-        {'current_q': 1, 'expression': "q1 == 'yes'", 'next_q': 2, 'priority': 0, 'question_name_to_index': {'q1': 1}, 'before_rule': False, 'edsl_version': '...', 'edsl_class_name': 'Rule'}
+        {'current_q': 1, 'expression': "q1 == 'yes'", 'next_q': 2, 'priority': 0, 'question_name_to_index': {'q1': 1}, 'before_rule': False}
         """
         return {
             "current_q": self.current_q,
@@ -133,6 +136,7 @@ class Rule:
             "question_name_to_index": self.question_name_to_index,
             "before_rule": self.before_rule,
         }
+        # return self._to_dict()
 
     @classmethod
     @remove_edsl_version
@@ -251,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

@@ -1,6 +1,6 @@
 """A collection of rules for a survey."""
 
-from typing import List, Union, Any
+from typing import List, Union, Any, Optional
 from collections import defaultdict, UserList
 
 from edsl.exceptions import (
@@ -24,7 +24,7 @@ NextQuestion = namedtuple(
 class RuleCollection(UserList):
     """A collection of rules for a particular survey."""
 
-    def __init__(self, num_questions: int = None, rules: List[Rule] = None):
+    def __init__(self, num_questions: Optional[int] = None, rules: List[Rule] = None):
         """Initialize the RuleCollection object.
 
         :param num_questions: The number of questions in the survey.
@@ -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
         )