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

edsl/jobs/interviews/Interview.py

@@ -110,9 +110,9 @@ class Interview:
         self.debug = debug
         self.iteration = iteration
         self.cache = cache
-        self.answers: dict[
-            str, str
-        ] = Answers()  # will get filled in as interview progresses
+        self.answers: dict[str, str] = (
+            Answers()
+        )  # will get filled in as interview progresses
         self.sidecar_model = sidecar_model
 
         # Trackers
@@ -143,9 +143,9 @@ class Interview:
         The keys are the question names; the values are the lists of status log changes for each task.
         """
         for task_creator in self.task_creators.values():
-            self._task_status_log_dict[
-                task_creator.question.question_name
-            ] = task_creator.status_log
+            self._task_status_log_dict[task_creator.question.question_name] = (
+                task_creator.status_log
+            )
         return self._task_status_log_dict
 
     @property
@@ -486,11 +486,11 @@ class Interview:
         """
         current_question_index: int = self.to_index[current_question.question_name]
 
-        next_question: Union[
-            int, EndOfSurvey
-        ] = self.survey.rule_collection.next_question(
-            q_now=current_question_index,
-            answers=self.answers | self.scenario | self.agent["traits"],
+        next_question: Union[int, EndOfSurvey] = (
+            self.survey.rule_collection.next_question(
+                q_now=current_question_index,
+                answers=self.answers | self.scenario | self.agent["traits"],
+            )
         )
 
         next_question_index = next_question.next_q

edsl/jobs/runners/JobsRunnerAsyncio.py

@@ -4,7 +4,6 @@ import asyncio
 import threading
 import warnings
 from typing import Coroutine, List, AsyncGenerator, Optional, Union, Generator, Type
-from uuid import UUID
 from collections import UserList
 
 from edsl.results.Results import Results
@@ -37,8 +36,6 @@ class JobsRunnerAsyncio:
     The Jobs object is a collection of interviews that are to be run.
     """
 
-    MAX_CONCURRENT_DEFAULT = 500
-
     def __init__(self, jobs: "Jobs"):
         self.jobs = jobs
         self.interviews: List["Interview"] = jobs.interviews()
@@ -46,53 +43,6 @@ class JobsRunnerAsyncio:
         self.total_interviews: List["Interview"] = []
         self._initialized = threading.Event()
 
-        from edsl.config import CONFIG
-
-        self.MAX_CONCURRENT = int(CONFIG.get("EDSL_MAX_CONCURRENT_TASKS"))
-        # print(f"MAX_CONCURRENT: {self.MAX_CONCURRENT}")
-
-    # async def run_async_generator(
-    #     self,
-    #     cache: Cache,
-    #     n: int = 1,
-    #     stop_on_exception: bool = False,
-    #     sidecar_model: Optional[LanguageModel] = None,
-    #     total_interviews: Optional[List["Interview"]] = None,
-    #     raise_validation_errors: bool = False,
-    # ) -> AsyncGenerator["Result", None]:
-    #     """Creates the tasks, runs them asynchronously, and returns the results as a Results object.
-
-    #     Completed tasks are yielded as they are completed.
-
-    #     :param n: how many times to run each interview
-    #     :param stop_on_exception: Whether to stop the interview if an exception is raised
-    #     :param sidecar_model: a language model to use in addition to the interview's model
-    #     :param total_interviews: A list of interviews to run can be provided instead.
-    #     :param raise_validation_errors: Whether to raise validation errors
-    #     """
-    #     tasks = []
-    #     if total_interviews:  # was already passed in total interviews
-    #         self.total_interviews = total_interviews
-    #     else:
-    #         self.total_interviews = list(
-    #             self._populate_total_interviews(n=n)
-    #         )  # Populate self.total_interviews before creating tasks
-    #     self._initialized.set()  # Signal that we're ready
-
-    #     for interview in self.total_interviews:
-    #         interviewing_task = self._build_interview_task(
-    #             interview=interview,
-    #             stop_on_exception=stop_on_exception,
-    #             sidecar_model=sidecar_model,
-    #             raise_validation_errors=raise_validation_errors,
-    #         )
-    #         tasks.append(asyncio.create_task(interviewing_task))
-
-    #     for task in asyncio.as_completed(tasks):
-    #         result = await task
-    #         self.jobs_runner_status.add_completed_interview(result)
-    #         yield result
-
     async def run_async_generator(
         self,
         cache: Cache,
@@ -102,10 +52,9 @@ class JobsRunnerAsyncio:
         total_interviews: Optional[List["Interview"]] = None,
         raise_validation_errors: bool = False,
     ) -> AsyncGenerator["Result", None]:
-        """Creates and processes tasks asynchronously, yielding results as they complete.
+        """Creates the tasks, runs them asynchronously, and returns the results as a Results object.
 
-        Tasks are created and processed in a streaming fashion rather than building the full list upfront.
-        Results are yielded as soon as they are available.
+        Completed tasks are yielded as they are completed.
 
         :param n: how many times to run each interview
         :param stop_on_exception: Whether to stop the interview if an exception is raised
@@ -113,70 +62,29 @@ class JobsRunnerAsyncio:
         :param total_interviews: A list of interviews to run can be provided instead.
         :param raise_validation_errors: Whether to raise validation errors
         """
-        # Initialize interviews iterator
-        if total_interviews:
-            interviews_iter = iter(total_interviews)
+        tasks = []
+        if total_interviews:  # was already passed in total interviews
             self.total_interviews = total_interviews
         else:
-            interviews_iter = self._populate_total_interviews(n=n)
-            self.total_interviews = list(interviews_iter)
-            interviews_iter = iter(self.total_interviews)  # Create fresh iterator
+            self.total_interviews = list(
+                self._populate_total_interviews(n=n)
+            )  # Populate self.total_interviews before creating tasks
 
         self._initialized.set()  # Signal that we're ready
 
-        # Keep track of active tasks
-        active_tasks = set()
+        for interview in self.total_interviews:
+            interviewing_task = self._build_interview_task(
+                interview=interview,
+                stop_on_exception=stop_on_exception,
+                sidecar_model=sidecar_model,
+                raise_validation_errors=raise_validation_errors,
+            )
+            tasks.append(asyncio.create_task(interviewing_task))
 
-        try:
-            while True:
-                # Add new tasks if we're below max_concurrent and there are more interviews
-                while len(active_tasks) < self.MAX_CONCURRENT:
-                    try:
-                        interview = next(interviews_iter)
-                        task = asyncio.create_task(
-                            self._build_interview_task(
-                                interview=interview,
-                                stop_on_exception=stop_on_exception,
-                                sidecar_model=sidecar_model,
-                                raise_validation_errors=raise_validation_errors,
-                            )
-                        )
-                        active_tasks.add(task)
-                        # Add callback to remove task from set when done
-                        task.add_done_callback(active_tasks.discard)
-                    except StopIteration:
-                        break
-
-                if not active_tasks:
-                    break
-
-                # Wait for next completed task
-                done, _ = await asyncio.wait(
-                    active_tasks, return_when=asyncio.FIRST_COMPLETED
-                )
-
-                # Process completed tasks
-                for task in done:
-                    try:
-                        result = await task
-                        self.jobs_runner_status.add_completed_interview(result)
-                        yield result
-                    except Exception as e:
-                        if stop_on_exception:
-                            # Cancel remaining tasks
-                            for t in active_tasks:
-                                if not t.done():
-                                    t.cancel()
-                            raise
-                        else:
-                            # Log error and continue
-                            # logger.error(f"Task failed with error: {e}")
-                            continue
-        finally:
-            # Ensure we cancel any remaining tasks if we exit early
-            for task in active_tasks:
-                if not task.done():
-                    task.cancel()
+        for task in asyncio.as_completed(tasks):
+            result = await task
+            self.jobs_runner_status.add_completed_interview(result)
+            yield result
 
     def _populate_total_interviews(
         self, n: int = 1
@@ -260,20 +168,20 @@ class JobsRunnerAsyncio:
 
         prompt_dictionary = {}
         for answer_key_name in answer_key_names:
-            prompt_dictionary[
-                answer_key_name + "_user_prompt"
-            ] = question_name_to_prompts[answer_key_name]["user_prompt"]
-            prompt_dictionary[
-                answer_key_name + "_system_prompt"
-            ] = question_name_to_prompts[answer_key_name]["system_prompt"]
+            prompt_dictionary[answer_key_name + "_user_prompt"] = (
+                question_name_to_prompts[answer_key_name]["user_prompt"]
+            )
+            prompt_dictionary[answer_key_name + "_system_prompt"] = (
+                question_name_to_prompts[answer_key_name]["system_prompt"]
+            )
 
         raw_model_results_dictionary = {}
         cache_used_dictionary = {}
         for result in valid_results:
             question_name = result.question_name
-            raw_model_results_dictionary[
-                question_name + "_raw_model_response"
-            ] = result.raw_model_response
+            raw_model_results_dictionary[question_name + "_raw_model_response"] = (
+                result.raw_model_response
+            )
             raw_model_results_dictionary[question_name + "_cost"] = result.cost
             one_use_buys = (
                 "NA"
@@ -337,25 +245,11 @@ class JobsRunnerAsyncio:
             if len(results.task_history.indices) > 5:
                 msg += f"Exceptions were raised in the following interviews: {results.task_history.indices}.\n"
 
-            import sys
-
-            print(msg, file=sys.stderr)
-            from edsl.config import CONFIG
-
-            if CONFIG.get("EDSL_OPEN_EXCEPTION_REPORT_URL") == "True":
-                open_in_browser = True
-            elif CONFIG.get("EDSL_OPEN_EXCEPTION_REPORT_URL") == "False":
-                open_in_browser = False
-            else:
-                raise Exception(
-                    "EDSL_OPEN_EXCEPTION_REPORT_URL", "must be either True or False"
-                )
-
-            # print("open_in_browser", open_in_browser)
-
+            print(msg)
+            # this is where exceptions are opening up
             filepath = results.task_history.html(
                 cta="Open report to see details.",
-                open_in_browser=open_in_browser,
+                open_in_browser=True,
                 return_link=True,
             )
 
@@ -385,7 +279,6 @@ class JobsRunnerAsyncio:
         progress_bar: bool = False,
         sidecar_model: Optional[LanguageModel] = None,
         jobs_runner_status: Optional[Type[JobsRunnerStatusBase]] = None,
-        job_uuid: Optional[UUID] = None,
         print_exceptions: bool = True,
         raise_validation_errors: bool = False,
     ) -> "Coroutine":
@@ -404,11 +297,13 @@ class JobsRunnerAsyncio:
 
         if jobs_runner_status is not None:
             self.jobs_runner_status = jobs_runner_status(
-                self, n=n, endpoint_url=endpoint_url, job_uuid=job_uuid
+                self, n=n, endpoint_url=endpoint_url
             )
         else:
             self.jobs_runner_status = JobsRunnerStatus(
-                self, n=n, endpoint_url=endpoint_url, job_uuid=job_uuid
+                self,
+                n=n,
+                endpoint_url=endpoint_url,
             )
 
         stop_event = threading.Event()

edsl/jobs/runners/JobsRunnerStatus.py

@@ -239,6 +239,7 @@ class JobsRunnerStatusBase(ABC):
         return stat_definitions[stat_name]()
 
     def update_progress(self, stop_event):
+
         while not stop_event.is_set():
             self.send_status_update()
             time.sleep(self.refresh_rate)
@@ -247,6 +248,7 @@ class JobsRunnerStatusBase(ABC):
 
 
 class JobsRunnerStatus(JobsRunnerStatusBase):
+
     @property
     def create_url(self) -> str:
         return f"{self.base_url}/api/v0/local-job"

edsl/jobs/tasks/TaskHistory.py

@@ -8,12 +8,7 @@ from edsl.jobs.tasks.task_status_enum import TaskStatus
 
 
 class TaskHistory:
-    def __init__(
-        self,
-        interviews: List["Interview"],
-        include_traceback: bool = False,
-        max_interviews: int = 10,
-    ):
+    def __init__(self, interviews: List["Interview"], include_traceback: bool = False):
         """
         The structure of a TaskHistory exception
 
@@ -27,7 +22,6 @@ class TaskHistory:
         self.include_traceback = include_traceback
 
         self._interviews = {index: i for index, i in enumerate(self.total_interviews)}
-        self.max_interviews = max_interviews
 
     @classmethod
     def example(cls):
@@ -81,6 +75,13 @@ class TaskHistory:
 
     def to_dict(self, add_edsl_version=True):
         """Return the TaskHistory as a dictionary."""
+        # return {
+        #     "exceptions": [
+        #         e.to_dict(include_traceback=self.include_traceback)
+        #         for e in self.exceptions
+        #     ],
+        #     "indices": self.indices,
+        # }
         d = {
             "interviews": [
                 i.to_dict(add_edsl_version=add_edsl_version)
@@ -123,11 +124,10 @@ class TaskHistory:
 
     def _repr_html_(self):
         """Return an HTML representation of the TaskHistory."""
-        d = self.to_dict(add_edsl_version=False)
-        data = [[k, v] for k, v in d.items()]
-        from tabulate import tabulate
+        from edsl.utilities.utilities import data_to_html
 
-        return tabulate(data, headers=["keys", "values"], tablefmt="html")
+        newdata = self.to_dict()["exceptions"]
+        return data_to_html(newdata, replace_new_lines=True)
 
     def show_exceptions(self, tracebacks=False):
         """Print the exceptions."""
@@ -257,6 +257,8 @@ class TaskHistory:
             for question_name, exceptions in interview.exceptions.items():
                 for exception in exceptions:
                     exception_type = exception.exception.__class__.__name__
+                    # exception_type = exception["exception"]
+                    # breakpoint()
                     if exception_type in exceptions_by_type:
                         exceptions_by_type[exception_type] += 1
                     else:
@@ -343,9 +345,9 @@ class TaskHistory:
 
         env = Environment(loader=TemplateLoader("edsl", "templates/error_reporting"))
 
-        # Get current memory usage at this point
-
+        # Load and render a template
         template = env.get_template("base.html")
+        # rendered_template = template.render(your_data=your_data)
 
         # Render the template with data
         output = template.render(
@@ -359,7 +361,6 @@ class TaskHistory:
             exceptions_by_model=self.exceptions_by_model,
             exceptions_by_service=self.exceptions_by_service,
             models_used=models_used,
-            max_interviews=self.max_interviews,
         )
         return output
 
@@ -369,7 +370,7 @@ class TaskHistory:
         return_link=False,
         css=None,
         cta="Open Report in New Tab",
-        open_in_browser=False,
+        open_in_browser=True,
     ):
         """Return an HTML report."""