edsl 0.1.53__py3-none-any.whl → 0.1.55__py3-none-any.whl

edsl/scenarios/tests/test_scenario_list_sources.py

@@ -0,0 +1,52 @@
+"""
+Tests for all registered source types in the ScenarioSource system.
+
+This module contains tests that verify the functionality of all registered
+source types in the system. It uses the Source registry to automatically
+test all available source types.
+"""
+
+import pytest
+from edsl.scenarios.scenario_source import Source
+from edsl.scenarios.scenario_list import ScenarioList
+
+def test_all_source_types():
+    """
+    Test that all registered source types can create an example instance
+    and convert it to a ScenarioList.
+    """
+    results = Source.test_all_sources()
+    
+    # Print detailed results for debugging
+    for source_type, success in results.items():
+        print(f"Source type {source_type}: {'✓' if success else '✗'}")
+    
+    # Assert that all source types succeeded
+    failed_sources = [source_type for source_type, success in results.items() if not success]
+    assert not failed_sources, f"The following source types failed: {failed_sources}"
+
+def test_source_registry_not_empty():
+    """Test that the source registry is not empty."""
+    registered_types = Source.get_registered_types()
+    assert len(registered_types) > 0, "No source types are registered"
+
+def test_each_source_type():
+    """
+    Test each source type individually with more detailed assertions.
+    """
+    for source_type in Source.get_registered_types():
+        source_class = Source.get_source_class(source_type)
+        
+        # Test example creation
+        example = source_class.example()
+        assert example is not None, f"Example creation failed for {source_type}"
+        
+        # Test to_scenario_list
+        scenario_list = example.to_scenario_list()
+        assert isinstance(scenario_list, ScenarioList), f"to_scenario_list did not return a ScenarioList for {source_type}"
+        assert len(scenario_list) > 0, f"Empty ScenarioList returned for {source_type}"
+
+def test_source_type_uniqueness():
+    """Test that all source types are unique."""
+    registered_types = Source.get_registered_types()
+    assert len(registered_types) == len(set(registered_types)), "Duplicate source types found in registry" 

edsl/surveys/survey.py

@@ -1691,6 +1691,28 @@ class Survey(Base):
             scenario, filename, return_link, css, cta, include_question_name
         )
 
+    def copy(self) -> "Survey":
+        """Create a deep copy of the survey using serialization.
+        
+        This method creates a completely independent copy of the survey by serializing
+        and then deserializing it. This ensures all components are properly copied
+        and maintains consistency with the survey's serialization format.
+        
+        Returns:
+            Survey: A new Survey instance that is a deep copy of the original.
+            
+        Examples:
+            >>> s = Survey.example()
+            >>> s2 = s.copy()
+            >>> s == s2
+            True
+            >>> s is s2
+            False
+            >>> s.questions[0] is s2.questions[0]
+            False
+        """
+        return Survey.from_dict(self.to_dict())
+
 
 def main():
     """Run the example survey."""

edsl/tasks/__init__.py

@@ -40,10 +40,12 @@ __all__ = [
     'TaskHistoryError'
 ]
 
+# Import TaskStatus first to prevent circular imports
+from .task_status_enum import TaskStatus, TaskStatusDescriptor
 from .task_history import TaskHistory
-from .question_task_creator import QuestionTaskCreator
 from .task_creators import TaskCreators
-from .task_status_enum import TaskStatus, TaskStatusDescriptor
+# Import question_task_creator last since it depends on other modules
+from .question_task_creator import QuestionTaskCreator
 from .exceptions import (
     TaskError,
     TaskStatusError,

edsl/tasks/task_history.py

@@ -23,20 +23,20 @@ from ..base import RepresentationMixin
 class TaskHistory(RepresentationMixin):
     """
     Records and analyzes the execution history of tasks across multiple interviews.
-    
+
     The TaskHistory class serves as a central repository for tracking task execution
     across multiple interviews. It provides methods for:
-    
+
     1. Error Analysis - Collecting, categorizing, and reporting exceptions
     2. Execution Visualization - Generating plots of task status over time
     3. Performance Metrics - Calculating timing statistics for tasks
     4. HTML Reports - Creating detailed interactive reports of execution
-    
+
     This class is particularly useful for debugging complex interview workflows,
     identifying performance bottlenecks, and understanding patterns in task execution.
     It supports both interactive exploration in notebooks and standalone report
     generation.
-    
+
     Key features:
     - Tracks exceptions with optional traceback storage
     - Provides visualizations of task status transitions
@@ -44,7 +44,7 @@ class TaskHistory(RepresentationMixin):
     - Computes statistics across interviews (by model, question type, etc.)
     - Exports to various formats (HTML, notebook, etc.)
     """
-    
+
     def __init__(
         self,
         interviews: List["Interview"] = None,
@@ -54,13 +54,13 @@ class TaskHistory(RepresentationMixin):
     ):
         """
         Initialize a TaskHistory to track execution across multiple interviews.
-        
+
         Parameters:
             interviews: List of Interview objects to track
             include_traceback: Whether to include full exception tracebacks
             max_interviews: Maximum number of interviews to display in reports
             interviews_with_exceptions_only: If True, only track interviews with exceptions
-        
+
         Example:
             >>> _ = TaskHistory.example()  # Create a sample TaskHistory
         """
@@ -86,8 +86,64 @@ class TaskHistory(RepresentationMixin):
         if self.interviews_with_exceptions_only and interview.exceptions == {}:
             return
 
-        self.total_interviews.append(interview)
-        self._interviews[len(self._interviews)] = interview
+        # Store only essential data from the interview to break strong reference
+        # Instead of a deep copy, we create a lightweight reference holder
+        class InterviewReference:
+            def __init__(self, interview: "Interview"):
+                # Store only the data we need for reporting
+                self.exceptions = interview.exceptions
+                self.task_status_logs = interview.task_status_logs
+                self.model = interview.model
+                self.survey = interview.survey
+
+                # Store metadata needed for serialization
+                self._interview_id = id(interview)
+
+            def to_dict(self, add_edsl_version=True):
+                """Create a serializable representation of the interview reference"""
+                # Create a simplified dict that has the required fields but doesn't
+                # maintain a strong reference to the original interview
+                data = {
+                    "id": self._interview_id,
+                    "type": "InterviewReference",
+                    "exceptions": self.exceptions.to_dict()
+                    if hasattr(self.exceptions, "to_dict")
+                    else {},
+                    "task_status_logs": {
+                        name: log.to_dict() if hasattr(log, "to_dict") else {}
+                        for name, log in self.task_status_logs.items()
+                    },
+                }
+
+                # Add model and survey info if they have to_dict methods
+                if hasattr(self.model, "to_dict"):
+                    data["model"] = self.model.to_dict(
+                        add_edsl_version=add_edsl_version
+                    )
+
+                if hasattr(self.survey, "to_dict"):
+                    data["survey"] = self.survey.to_dict(
+                        add_edsl_version=add_edsl_version
+                    )
+
+                if add_edsl_version:
+                    from edsl import __version__
+
+                    data["edsl_version"] = __version__
+
+                return data
+
+            def __getattr__(self, name):
+                # Handle any missing attributes by returning None
+                # This provides compatibility with code that might access
+                # other interview attributes we haven't explicitly stored
+                return None
+
+        # Create a reference object instead of keeping the full interview
+        interview_ref = InterviewReference(interview)
+
+        self.total_interviews.append(interview_ref)
+        self._interviews[len(self._interviews)] = interview_ref
 
     @classmethod
     def example(cls):
@@ -96,7 +152,6 @@ class TaskHistory(RepresentationMixin):
 
         j = Jobs.example(throw_exception_probability=1, test_model=True)
 
-
         results = j.run(
             print_exceptions=False,
             skip_retry=True,
@@ -138,13 +193,37 @@ class TaskHistory(RepresentationMixin):
 
     def to_dict(self, add_edsl_version=True):
         """Return the TaskHistory as a dictionary."""
+        # Serialize each interview object
+        interview_dicts = []
+        for i in self.total_interviews:
+            # Use to_dict method if available
+            if hasattr(i, "to_dict"):
+                try:
+                    interview_dicts.append(i.to_dict(add_edsl_version=add_edsl_version))
+                except Exception:
+                    # Fallback if to_dict fails
+                    interview_dicts.append(
+                        {
+                            "type": "InterviewReference",
+                            "exceptions": getattr(i, "exceptions", {}),
+                            "task_status_logs": getattr(i, "task_status_logs", {}),
+                        }
+                    )
+            else:
+                # Fallback if no to_dict method
+                interview_dicts.append(
+                    {
+                        "type": "InterviewReference",
+                        "exceptions": getattr(i, "exceptions", {}),
+                        "task_status_logs": getattr(i, "task_status_logs", {}),
+                    }
+                )
+
         d = {
-            "interviews": [
-                i.to_dict(add_edsl_version=add_edsl_version)
-                for i in self.total_interviews
-            ],
+            "interviews": interview_dicts,
             "include_traceback": self.include_traceback,
         }
+
         if add_edsl_version:
             from .. import __version__
 
@@ -158,10 +237,76 @@ class TaskHistory(RepresentationMixin):
         if data is None:
             return cls([], include_traceback=False)
 
-        from ..interviews import Interview
+        # Create an instance without interviews
+        instance = cls([], include_traceback=data.get("include_traceback", False))
 
-        interviews = [Interview.from_dict(i) for i in data["interviews"]]
-        return cls(interviews, include_traceback=data["include_traceback"])
+        # Create a custom interview-like object for each serialized interview
+        for interview_data in data.get("interviews", []):
+            # Check if this is one of our InterviewReference objects
+            if (
+                isinstance(interview_data, dict)
+                and interview_data.get("type") == "InterviewReference"
+            ):
+                # Create our InterviewReference directly
+                class DeserializedInterviewRef:
+                    def __init__(self, data):
+                        # Convert exceptions dictionary to InterviewExceptionCollection
+                        from ..interviews.exception_tracking import (
+                            InterviewExceptionCollection,
+                        )
+
+                        exceptions_data = data.get("exceptions", {})
+                        self.exceptions = (
+                            InterviewExceptionCollection.from_dict(exceptions_data)
+                            if exceptions_data
+                            else InterviewExceptionCollection()
+                        )
+                        self.task_status_logs = data.get("task_status_logs", {})
+                        self.model = data.get("model", {})
+                        self.survey = data.get("survey", {})
+
+                    def to_dict(self, add_edsl_version=True):
+                        return {
+                            "type": "InterviewReference",
+                            "exceptions": self.exceptions.to_dict()
+                            if hasattr(self.exceptions, "to_dict")
+                            else self.exceptions,
+                            "task_status_logs": self.task_status_logs,
+                            "model": self.model,
+                            "survey": self.survey,
+                        }
+
+                # Create the reference and add it directly
+                ref = DeserializedInterviewRef(interview_data)
+                instance.total_interviews.append(ref)
+                instance._interviews[len(instance._interviews)] = ref
+            else:
+                # For backward compatibility, try to use Interview class
+                try:
+                    from ..interviews import Interview
+
+                    interview = Interview.from_dict(interview_data)
+                    # This will make a reference copy through add_interview
+                    instance.add_interview(interview)
+                except Exception:
+                    # If we can't deserialize properly, add a minimal placeholder
+                    class MinimalInterviewRef:
+                        def __init__(self):
+                            from ..interviews.exception_tracking import (
+                                InterviewExceptionCollection,
+                            )
+
+                            self.exceptions = InterviewExceptionCollection()
+                            self.task_status_logs = {}
+
+                        def to_dict(self, add_edsl_version=True):
+                            return {"type": "MinimalInterviewRef"}
+
+                    ref = MinimalInterviewRef()
+                    instance.total_interviews.append(ref)
+                    instance._interviews[len(instance._interviews)] = ref
+
+        return instance
 
     @property
     def has_exceptions(self) -> bool:
@@ -187,8 +332,12 @@ class TaskHistory(RepresentationMixin):
         """Return a list of all the updates."""
         updates = []
         for interview in self.total_interviews:
-            for question_name, logs in interview.task_status_logs.items():
-                updates.append(logs)
+            # Check if task_status_logs exists and is a dictionary
+            if hasattr(interview, "task_status_logs") and isinstance(
+                interview.task_status_logs, dict
+            ):
+                for question_name, logs in interview.task_status_logs.items():
+                    updates.append(logs)
         return updates
 
     def print(self):
@@ -218,6 +367,14 @@ class TaskHistory(RepresentationMixin):
     def plotting_data(self, num_periods=100):
         updates = self.get_updates()
 
+        # Handle the case when updates is empty
+        if not updates:
+            # Return a list of dictionaries with all task statuses set to 0
+            return [
+                {task_status: 0 for task_status in TaskStatus}
+                for _ in range(num_periods)
+            ]
+
         min_t = min([update.min_time for update in updates])
         max_t = max([update.max_time for update in updates])
         delta_t = (max_t - min_t) / (num_periods * 1.0)
@@ -325,36 +482,38 @@ class TaskHistory(RepresentationMixin):
         """Return a dictionary of unique exceptions organized by type, service, model, and question name."""
         exceptions_table = {}
         seen_exceptions = set()
-        
+
         for interview in self.total_interviews:
             for question_name, exceptions in interview.exceptions.items():
                 for exception in exceptions:
                     # Create a unique identifier for this exception based on its content
                     exception_key = (
                         exception.exception.__class__.__name__,  # Exception type
-                        interview.model._inference_service_,     # Service
-                        interview.model.model,                   # Model
-                        question_name,                           # Question name
-                        exception.name,                          # Exception name
-                        str(exception.traceback)[:100] if exception.traceback else "",  # Truncated traceback
+                        interview.model._inference_service_,  # Service
+                        interview.model.model,  # Model
+                        question_name,  # Question name
+                        exception.name,  # Exception name
+                        str(exception.traceback)[:100]
+                        if exception.traceback
+                        else "",  # Truncated traceback
                     )
-                    
+
                     # Only count if we haven't seen this exact exception before
                     if exception_key not in seen_exceptions:
                         seen_exceptions.add(exception_key)
-                        
+
                         # Add to the summary table
                         table_key = (
                             exception.exception.__class__.__name__,  # Exception type
-                            interview.model._inference_service_,     # Service
-                            interview.model.model,                   # Model
-                            question_name,                           # Question name
+                            interview.model._inference_service_,  # Service
+                            interview.model.model,  # Model
+                            question_name,  # Question name
                         )
-                        
+
                         if table_key not in exceptions_table:
                             exceptions_table[table_key] = 0
                         exceptions_table[table_key] += 1
-        
+
         return exceptions_table
 
     @property
@@ -478,22 +637,22 @@ class TaskHistory(RepresentationMixin):
     ) -> Optional[str]:
         """
         Generate and display an interactive HTML report of task execution.
-        
+
         This method creates a comprehensive HTML report showing task execution details,
         exceptions, timing information, and statistics across all tracked interviews.
         In notebook environments, it displays an embedded preview with a link to open
         the full report in a new tab.
-        
+
         Parameters:
             filename: Path to save the HTML report (if None, a temporary file is created)
             return_link: If True, return the path to the saved HTML file
             css: Custom CSS to apply to the report (if None, uses default styling)
             cta: HTML for the "Call to Action" link text
             open_in_browser: If True, automatically open the report in the default browser
-            
+
         Returns:
             If return_link is True, returns the path to the saved HTML file; otherwise None
-            
+
         Notes:
             - In Jupyter notebooks, displays an embedded preview with a link
             - In terminal environments, saves the file and prints its location
@@ -574,3 +733,6 @@ if __name__ == "__main__":
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)
+
+    # Run the reference test
+    test_no_strong_reference()

edsl/tests/scenarios/test_ScenarioSource.py

@@ -0,0 +1,51 @@
+"""
+Tests for all registered source types in the ScenarioSource system.
+
+This module contains tests that verify the functionality of all registered
+source types in the system. It uses the Source registry to automatically
+test all available source types.
+"""
+
+import pytest
+from edsl.scenarios.scenario_source import Source, ScenarioList
+
+def test_all_source_types():
+    """
+    Test that all registered source types can create an example instance
+    and convert it to a ScenarioList.
+    """
+    results = Source.test_all_sources()
+    
+    # Print detailed results for debugging
+    for source_type, success in results.items():
+        print(f"Source type {source_type}: {'✓' if success else '✗'}")
+    
+    # Assert that all source types succeeded
+    failed_sources = [source_type for source_type, success in results.items() if not success]
+    assert not failed_sources, f"The following source types failed: {failed_sources}"
+
+def test_source_registry_not_empty():
+    """Test that the source registry is not empty."""
+    registered_types = Source.get_registered_types()
+    assert len(registered_types) > 0, "No source types are registered"
+
+def test_each_source_type():
+    """
+    Test each source type individually with more detailed assertions.
+    """
+    for source_type in Source.get_registered_types():
+        source_class = Source.get_source_class(source_type)
+        
+        # Test example creation
+        example = source_class.example()
+        assert example is not None, f"Example creation failed for {source_type}"
+        
+        # Test to_scenario_list
+        scenario_list = example.to_scenario_list()
+        assert isinstance(scenario_list, ScenarioList), f"to_scenario_list did not return a ScenarioList for {source_type}"
+        assert len(scenario_list) > 0, f"Empty ScenarioList returned for {source_type}"
+
+def test_source_type_uniqueness():
+    """Test that all source types are unique."""
+    registered_types = Source.get_registered_types()
+    assert len(registered_types) == len(set(registered_types)), "Duplicate source types found in registry" 

edsl/tests/scenarios/test_scenario_list_sources.py

@@ -0,0 +1,51 @@
+"""
+Tests for all registered source types in the ScenarioSource system.
+
+This module contains tests that verify the functionality of all registered
+source types in the system. It uses the Source registry to automatically
+test all available source types.
+"""
+
+import pytest
+from edsl.scenarios.scenario_source import Source, ScenarioList
+
+def test_all_source_types():
+    """
+    Test that all registered source types can create an example instance
+    and convert it to a ScenarioList.
+    """
+    results = Source.test_all_sources()
+    
+    # Print detailed results for debugging
+    for source_type, success in results.items():
+        print(f"Source type {source_type}: {'✓' if success else '✗'}")
+    
+    # Assert that all source types succeeded
+    failed_sources = [source_type for source_type, success in results.items() if not success]
+    assert not failed_sources, f"The following source types failed: {failed_sources}"
+
+def test_source_registry_not_empty():
+    """Test that the source registry is not empty."""
+    registered_types = Source.get_registered_types()
+    assert len(registered_types) > 0, "No source types are registered"
+
+def test_each_source_type():
+    """
+    Test each source type individually with more detailed assertions.
+    """
+    for source_type in Source.get_registered_types():
+        source_class = Source.get_source_class(source_type)
+        
+        # Test example creation
+        example = source_class.example()
+        assert example is not None, f"Example creation failed for {source_type}"
+        
+        # Test to_scenario_list
+        scenario_list = example.to_scenario_list()
+        assert isinstance(scenario_list, ScenarioList), f"to_scenario_list did not return a ScenarioList for {source_type}"
+        assert len(scenario_list) > 0, f"Empty ScenarioList returned for {source_type}"
+
+def test_source_type_uniqueness():
+    """Test that all source types are unique."""
+    registered_types = Source.get_registered_types()
+    assert len(registered_types) == len(set(registered_types)), "Duplicate source types found in registry" 

edsl/utilities/__init__.py

@@ -18,7 +18,7 @@ from .utilities import (
 )
 
 # Decorator utilities
-from .decorators import sync_wrapper, jupyter_nb_handler
+from .decorators import sync_wrapper, jupyter_nb_handler, memory_profile
 
 # Standalone utilities
 from .is_notebook import is_notebook
@@ -43,6 +43,7 @@ __all__ = [
     "is_gzipped",
     "sync_wrapper",
     "jupyter_nb_handler",
+    "memory_profile",
     "is_notebook",
     "is_valid_variable_name",
     "sanitize_string"