edsl 0.1.39.dev1__py3-none-any.whl → 0.1.39.dev2__py3-none-any.whl

edsl/jobs/loggers/HTMLTableJobLogger.py

@@ -0,0 +1,304 @@
+import re
+import uuid
+from datetime import datetime
+from IPython.display import display, HTML
+from edsl.jobs.JobsRemoteInferenceLogger import JobLogger
+from edsl.jobs.jobs_status_enums import JobsStatus
+
+
+class HTMLTableJobLogger(JobLogger):
+    def __init__(self, verbose=True, theme="auto", **kwargs):
+        super().__init__(verbose=verbose)
+        self.display_handle = display(HTML(""), display_id=True)
+        self.current_message = None
+        self.log_id = str(uuid.uuid4())
+        self.is_expanded = True
+        self.spinner_chars = ["◐", "◓", "◑", "◒"]
+        self.spinner_idx = 0
+        self.theme = theme  # Can be "auto", "light", or "dark"
+
+        # Initialize CSS once when the logger is created
+        self._init_css()
+
+    def _init_css(self):
+        """Initialize the CSS styles with enhanced theme support"""
+        css = """
+        <style>
+            /* Base theme variables */
+            :root {
+                --jl-bg-primary: #ffffff;
+                --jl-bg-secondary: #f5f5f5;
+                --jl-border-color: #e0e0e0;
+                --jl-text-primary: #24292e;
+                --jl-text-secondary: #586069;
+                --jl-link-color: #0366d6;
+                --jl-success-color: #28a745;
+                --jl-error-color: #d73a49;
+                --jl-header-bg: #f1f1f1;
+            }
+            
+            /* Dark theme variables */
+            .theme-dark {
+                --jl-bg-primary: #1e1e1e;
+                --jl-bg-secondary: #252526;
+                --jl-border-color: #2d2d2d;
+                --jl-text-primary: #cccccc;
+                --jl-text-secondary: #999999;
+                --jl-link-color: #4e94ce;
+                --jl-success-color: #89d185;
+                --jl-error-color: #f14c4c;
+                --jl-header-bg: #333333;
+            }
+
+            /* High contrast theme variables */
+            .theme-high-contrast {
+                --jl-bg-primary: #000000;
+                --jl-bg-secondary: #1a1a1a;
+                --jl-border-color: #404040;
+                --jl-text-primary: #ffffff;
+                --jl-text-secondary: #cccccc;
+                --jl-link-color: #66b3ff;
+                --jl-success-color: #00ff00;
+                --jl-error-color: #ff0000;
+                --jl-header-bg: #262626;
+            }
+            
+            .job-logger {
+                font-family: system-ui, -apple-system, sans-serif;
+                max-width: 800px;
+                margin: 10px 0;
+                color: var(--jl-text-primary);
+                box-shadow: 0 1px 3px rgba(0,0,0,0.12);
+                border-radius: 4px;
+                overflow: hidden;
+            }
+            
+            .job-logger-header {
+                padding: 12px 16px;
+                background: var(--jl-header-bg);
+                border: none;
+                border-radius: 4px 4px 0 0;
+                cursor: pointer;
+                color: var(--jl-text-primary);
+                user-select: none;
+                font-weight: 500;
+                letter-spacing: 0.3px;
+                display: flex;
+                justify-content: space-between;
+                align-items: center;
+            }
+            
+            .theme-select {
+                padding: 4px 8px;
+                border-radius: 4px;
+                border: 1px solid var(--jl-border-color);
+                background: var(--jl-bg-primary);
+                color: var(--jl-text-primary);
+                font-size: 0.9em;
+            }
+            
+            .job-logger-table {
+                width: 100%;
+                border-collapse: separate;
+                border-spacing: 0;
+                background: var(--jl-bg-primary);
+                border: 1px solid var(--jl-border-color);
+                margin-top: -1px;
+            }
+            
+            .job-logger-cell {
+                padding: 12px 16px;
+                border-bottom: 1px solid var(--jl-border-color);
+                line-height: 1.4;
+            }
+            
+            .job-logger-label {
+                font-weight: 500;
+                color: var(--jl-text-primary);
+                width: 25%;
+                background: var(--jl-bg-secondary);
+            }
+            
+            .job-logger-value {
+                color: var(--jl-text-secondary);
+                word-break: break-word;
+            }
+            
+            .job-logger-status {
+                margin: 0;
+                padding: 12px 16px;
+                background-color: var(--jl-bg-secondary);
+                border: 1px solid var(--jl-border-color);
+                border-top: none;
+                border-radius: 0 0 4px 4px;
+                color: var(--jl-text-primary);
+                font-size: 0.95em;
+            }
+        </style>
+        
+        <script>
+            class ThemeManager {
+                constructor(logId, initialTheme = 'auto') {
+                    this.logId = logId;
+                    this.currentTheme = initialTheme;
+                    this.darkModeMediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+                    this.init();
+                }
+                
+                init() {
+                    this.setupThemeSwitcher();
+                    this.updateTheme(this.currentTheme);
+                    
+                    this.darkModeMediaQuery.addListener(() => {
+                        if (this.currentTheme === 'auto') {
+                            this.updateTheme('auto');
+                        }
+                    });
+                }
+                
+                setupThemeSwitcher() {
+                    const logger = document.querySelector(`#logger-${this.logId}`);
+                    if (!logger) return;
+                    
+                    const switcher = document.createElement('div');
+                    switcher.className = 'theme-switcher';
+                    switcher.innerHTML = `
+                        <select id="theme-select-${this.logId}" class="theme-select">
+                            <option value="auto">Auto</option>
+                            <option value="light">Light</option>
+                            <option value="dark">Dark</option>
+                            <option value="high-contrast">High Contrast</option>
+                        </select>
+                    `;
+                    
+                    const header = logger.querySelector('.job-logger-header');
+                    header.appendChild(switcher);
+                    
+                    const select = switcher.querySelector('select');
+                    select.value = this.currentTheme;
+                    select.addEventListener('change', (e) => {
+                        this.updateTheme(e.target.value);
+                    });
+                }
+                
+                updateTheme(theme) {
+                    const logger = document.querySelector(`#logger-${this.logId}`);
+                    if (!logger) return;
+                    
+                    this.currentTheme = theme;
+                    
+                    logger.classList.remove('theme-light', 'theme-dark', 'theme-high-contrast');
+                    
+                    if (theme === 'auto') {
+                        const isDark = this.darkModeMediaQuery.matches;
+                        logger.classList.add(isDark ? 'theme-dark' : 'theme-light');
+                    } else {
+                        logger.classList.add(`theme-${theme}`);
+                    }
+                    
+                    try {
+                        localStorage.setItem('jobLoggerTheme', theme);
+                    } catch (e) {
+                        console.warn('Unable to save theme preference:', e);
+                    }
+                }
+            }
+            
+            window.initThemeManager = (logId, initialTheme) => {
+                new ThemeManager(logId, initialTheme);
+            };
+        </script>
+        """
+
+        init_script = f"""
+        <script>
+            document.addEventListener('DOMContentLoaded', () => {{
+                window.initThemeManager('{self.log_id}', '{self.theme}');
+            }});
+        </script>
+        """
+
+        display(HTML(css + init_script))
+
+    def _get_table_row(self, key: str, value: str) -> str:
+        """Generate a table row with key-value pair"""
+        return f"""
+            <tr>
+                <td class="job-logger-cell job-logger-label">{key}</td>
+                <td class="job-logger-cell job-logger-value">{value if value else 'None'}</td>
+            </tr>
+        """
+
+    def _linkify(self, text: str) -> str:
+        """Convert URLs in text to clickable links"""
+        url_pattern = r'(https?://[^\s<>"]+|www\.[^\s<>"]+)'
+        return re.sub(
+            url_pattern,
+            r'<a href="\1" target="_blank" class="job-logger-link">\1</a>',
+            text,
+        )
+
+    def _get_spinner(self, status: JobsStatus) -> str:
+        """Get the current spinner frame if status is running"""
+        if status == JobsStatus.RUNNING:
+            spinner = self.spinner_chars[self.spinner_idx]
+            self.spinner_idx = (self.spinner_idx + 1) % len(self.spinner_chars)
+            return f'<span style="margin-right: 8px;">{spinner}</span>'
+        elif status == JobsStatus.COMPLETED:
+            return (
+                '<span style="margin-right: 8px;" class="job-logger-success">✓</span>'
+            )
+        elif status == JobsStatus.FAILED:
+            return '<span style="margin-right: 8px;" class="job-logger-error">✗</span>'
+        return ""
+
+    def _get_html(self, status: JobsStatus = JobsStatus.RUNNING) -> str:
+        """Generate the complete HTML display with theme support"""
+        info_rows = ""
+        for field, _ in self.jobs_info.__annotations__.items():
+            if field != "pretty_names":
+                value = getattr(self.jobs_info, field)
+                value = self._linkify(str(value)) if value else None
+                pretty_name = self.jobs_info.pretty_names.get(
+                    field, field.replace("_", " ").title()
+                )
+                info_rows += self._get_table_row(pretty_name, value)
+
+        message_html = ""
+        if self.current_message:
+            spinner = self._get_spinner(status)
+            message_html = f"""
+                <div class="job-logger-status">
+                    {spinner}<strong>Current Status:</strong> {self._linkify(self.current_message)}
+                </div>
+            """
+
+        display_style = "block" if self.is_expanded else "none"
+        arrow = "▼" if self.is_expanded else "▶"
+
+        return f"""
+            <!-- #region Remove Inference Info -->
+            <div id="logger-{self.log_id}" class="job-logger">
+                <div class="job-logger-header">
+                    <span>
+                        <span id="arrow-{self.log_id}">{arrow}</span> 
+                        Job Status ({datetime.now().strftime('%Y-%m-%d %H:%M:%S')})
+                    </span>
+                </div>
+                <div id="content-{self.log_id}" style="display: {display_style};">
+                    <table class="job-logger-table">
+                        {info_rows}
+                    </table>
+                    {message_html}
+                </div>
+            </div>
+            <!-- # endregion -->
+        """
+
+    def update(self, message: str, status: JobsStatus = JobsStatus.RUNNING):
+        """Update the display with new message and current JobsInfo state"""
+        self.current_message = message
+        if self.verbose:
+            self.display_handle.update(HTML(self._get_html(status)))
+        else:
+            return None

edsl/jobs/runners/JobsRunnerAsyncio.py

@@ -37,61 +37,17 @@ class JobsRunnerAsyncio:
     The Jobs object is a collection of interviews that are to be run.
     """
 
-    MAX_CONCURRENT_DEFAULT = 500
-
-    def __init__(self, jobs: "Jobs"):
+    def __init__(self, jobs: "Jobs", bucket_collection: "BucketCollection"):
         self.jobs = jobs
         self.interviews: List["Interview"] = jobs.interviews()
-        self.bucket_collection: "BucketCollection" = jobs.bucket_collection
+        self.bucket_collection: "BucketCollection" = bucket_collection
+
         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,
@@ -297,6 +253,7 @@ class JobsRunnerAsyncio:
             generated_tokens=generated_tokens_dict,
             comments_dict=comments_dict,
             cache_used_dict=cache_used_dictionary,
+            indices=interview.indices,
         )
         result.interview_hash = hash(interview)
 
@@ -351,8 +308,6 @@ class JobsRunnerAsyncio:
                     "EDSL_OPEN_EXCEPTION_REPORT_URL", "must be either True or False"
                 )
 
-            # print("open_in_browser", open_in_browser)
-
             filepath = results.task_history.html(
                 cta="Open report to see details.",
                 open_in_browser=open_in_browser,

edsl/jobs/tasks/QuestionTaskCreator.py

@@ -1,17 +1,17 @@
 import asyncio
-from typing import Callable, Union, List
+from typing import Callable, Union, List, TYPE_CHECKING
 from collections import UserList, UserDict
 
-from edsl.jobs.buckets import ModelBuckets
-from edsl.exceptions import InterviewErrorPriorTaskCanceled
+from edsl.exceptions.jobs import InterviewErrorPriorTaskCanceled
 
-from edsl.jobs.interviews.InterviewStatusDictionary import InterviewStatusDictionary
 from edsl.jobs.tasks.task_status_enum import TaskStatus, TaskStatusDescriptor
 from edsl.jobs.tasks.TaskStatusLog import TaskStatusLog
-from edsl.jobs.tokens.InterviewTokenUsage import InterviewTokenUsage
 from edsl.jobs.tokens.TokenUsage import TokenUsage
 from edsl.jobs.Answers import Answers
-from edsl.questions.QuestionBase import QuestionBase
+
+if TYPE_CHECKING:
+    from edsl.questions.QuestionBase import QuestionBase
+    from edsl.jobs.buckets import ModelBuckets
 
 
 class TokensUsed(UserDict):
@@ -24,7 +24,6 @@ class TokensUsed(UserDict):
 
 class QuestionTaskCreator(UserList):
     """Class to create and manage a single question and its dependencies.
-    The class is an instance of a UserList of tasks that must be completed before the focal task can be run.
 
     It is a UserList with all the tasks that must be completed before the focal task can be run.
     The focal task is the question that we are interested in answering.
@@ -35,9 +34,9 @@ class QuestionTaskCreator(UserList):
     def __init__(
         self,
         *,
-        question: QuestionBase,
+        question: "QuestionBase",
         answer_question_func: Callable,
-        model_buckets: ModelBuckets,
+        model_buckets: "ModelBuckets",
         token_estimator: Union[Callable, None] = None,
         iteration: int = 0,
     ):
@@ -51,14 +50,15 @@ class QuestionTaskCreator(UserList):
 
         """
         super().__init__([])
-        # answer_question_func is the 'interview.answer_question_and_record_task" method
         self.answer_question_func = answer_question_func
         self.question = question
         self.iteration = iteration
 
         self.model_buckets = model_buckets
+
         self.requests_bucket = self.model_buckets.requests_bucket
         self.tokens_bucket = self.model_buckets.tokens_bucket
+
         self.status_log = TaskStatusLog()
 
         def fake_token_estimator(question):
@@ -125,11 +125,13 @@ class QuestionTaskCreator(UserList):
 
         await self.tokens_bucket.get_tokens(requested_tokens)
 
-        if (estimated_wait_time := self.requests_bucket.wait_time(1)) > 0:
+        if (estimated_wait_time := self.model_buckets.requests_bucket.wait_time(1)) > 0:
             self.waiting = True  #  do we need this?
             self.task_status = TaskStatus.WAITING_FOR_REQUEST_CAPACITY
 
-        await self.requests_bucket.get_tokens(1, cheat_bucket_capacity=True)
+        await self.model_buckets.requests_bucket.get_tokens(
+            1, cheat_bucket_capacity=True
+        )
 
         self.task_status = TaskStatus.API_CALL_IN_PROGRESS
         try:
@@ -142,22 +144,22 @@ class QuestionTaskCreator(UserList):
             raise e
 
         if results.cache_used:
-            self.tokens_bucket.add_tokens(requested_tokens)
-            self.requests_bucket.add_tokens(1)
+            self.model_buckets.tokens_bucket.add_tokens(requested_tokens)
+            self.model_buckets.requests_bucket.add_tokens(1)
             self.from_cache = True
             # Turbo mode means that we don't wait for tokens or requests.
-            self.tokens_bucket.turbo_mode_on()
-            self.requests_bucket.turbo_mode_on()
+            self.model_buckets.tokens_bucket.turbo_mode_on()
+            self.model_buckets.requests_bucket.turbo_mode_on()
         else:
-            self.tokens_bucket.turbo_mode_off()
-            self.requests_bucket.turbo_mode_off()
+            self.model_buckets.tokens_bucket.turbo_mode_off()
+            self.model_buckets.requests_bucket.turbo_mode_off()
 
         return results
 
     @classmethod
     def example(cls):
         """Return an example instance of the class."""
-        from edsl import QuestionFreeText
+        from edsl.questions.QuestionFreeText import QuestionFreeText
         from edsl.jobs.buckets.ModelBuckets import ModelBuckets
 
         m = ModelBuckets.infinity_bucket()

edsl/jobs/tasks/TaskHistory.py

@@ -1,13 +1,11 @@
 from typing import List, Optional
 from io import BytesIO
-import webbrowser
-import os
 import base64
-from importlib import resources
 from edsl.jobs.tasks.task_status_enum import TaskStatus
+from edsl.Base import RepresentationMixin
 
 
-class TaskHistory:
+class TaskHistory(RepresentationMixin):
     def __init__(
         self,
         interviews: List["Interview"],
@@ -121,14 +119,6 @@ class TaskHistory:
         """Return True if there are any exceptions."""
         return len(self.unfixed_exceptions) > 0
 
-    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
-
-        return tabulate(data, headers=["keys", "values"], tablefmt="html")
-
     def show_exceptions(self, tracebacks=False):
         """Print the exceptions."""
         for index in self.indices:
@@ -240,11 +230,15 @@ class TaskHistory:
             plt.show()
 
     def css(self):
+        from importlib import resources
+
         env = resources.files("edsl").joinpath("templates/error_reporting")
         css = env.joinpath("report.css").read_text()
         return css
 
     def javascript(self):
+        from importlib import resources
+
         env = resources.files("edsl").joinpath("templates/error_reporting")
         js = env.joinpath("report.js").read_text()
         return js
@@ -281,7 +275,7 @@ class TaskHistory:
         exceptions_by_question_name = {}
         for interview in self.total_interviews:
             for question_name, exceptions in interview.exceptions.items():
-                question_type = interview.survey.get_question(
+                question_type = interview.survey._get_question_by_name(
                     question_name
                 ).question_type
                 if (question_name, question_type) not in exceptions_by_question_name:
@@ -330,8 +324,11 @@ class TaskHistory:
         }
         return sorted_exceptions_by_model
 
-    def generate_html_report(self, css: Optional[str]):
-        performance_plot_html = self.plot(num_periods=100, get_embedded_html=True)
+    def generate_html_report(self, css: Optional[str], include_plot=False):
+        if include_plot:
+            performance_plot_html = self.plot(num_periods=100, get_embedded_html=True)
+        else:
+            performance_plot_html = ""
 
         if css is None:
             css = self.css()
@@ -409,6 +406,8 @@ class TaskHistory:
             print(f"Exception report saved to {filename}")
 
         if open_in_browser:
+            import webbrowser
+
             webbrowser.open(f"file://{os.path.abspath(filename)}")
 
         if return_link:

edsl/jobs/tasks/task_status_enum.py

@@ -3,8 +3,6 @@ from collections import UserDict
 import enum
 import time
 
-# from edsl.jobs.tasks.TaskStatusLogEntry import TaskStatusLogEntry
-
 
 class TaskStatus(enum.Enum):
     "These are the possible states a task can be in."

edsl/language_models/ComputeCost.py

@@ -0,0 +1,63 @@
+from typing import Any, Union
+
+
+class ComputeCost:
+    def __init__(self, language_model: "LanguageModel"):
+        self.language_model = language_model
+        self._price_lookup = None
+
+    @property
+    def price_lookup(self):
+        if self._price_lookup is None:
+            from edsl.coop import Coop
+
+            c = Coop()
+            self._price_lookup = c.fetch_prices()
+        return self._price_lookup
+
+    def cost(self, raw_response: dict[str, Any]) -> Union[float, str]:
+        """Return the dollar cost of a raw response."""
+
+        usage = self.get_usage_dict(raw_response)
+        from edsl.coop import Coop
+
+        c = Coop()
+        price_lookup = c.fetch_prices()
+        key = (self._inference_service_, self.model)
+        if key not in price_lookup:
+            return f"Could not find price for model {self.model} in the price lookup."
+
+        relevant_prices = price_lookup[key]
+        try:
+            input_tokens = int(usage[self.input_token_name])
+            output_tokens = int(usage[self.output_token_name])
+        except Exception as e:
+            return f"Could not fetch tokens from model response: {e}"
+
+        try:
+            inverse_output_price = relevant_prices["output"]["one_usd_buys"]
+            inverse_input_price = relevant_prices["input"]["one_usd_buys"]
+        except Exception as e:
+            if "output" not in relevant_prices:
+                return f"Could not fetch prices from {relevant_prices} - {e}; Missing 'output' key."
+            if "input" not in relevant_prices:
+                return f"Could not fetch prices from {relevant_prices} - {e}; Missing 'input' key."
+            return f"Could not fetch prices from {relevant_prices} - {e}"
+
+        if inverse_input_price == "infinity":
+            input_cost = 0
+        else:
+            try:
+                input_cost = input_tokens / float(inverse_input_price)
+            except Exception as e:
+                return f"Could not compute input price - {e}."
+
+        if inverse_output_price == "infinity":
+            output_cost = 0
+        else:
+            try:
+                output_cost = output_tokens / float(inverse_output_price)
+            except Exception as e:
+                return f"Could not compute output price - {e}"
+
+        return input_cost + output_cost