edsl 0.1.14__py3-none-any.whl → 0.1.40__py3-none-any.whl

edsl/jobs/interviews/InterviewStatistic.py

@@ -0,0 +1,63 @@
+import asyncio
+from enum import Enum
+from typing import Literal, List, Type, DefaultDict
+from collections import UserDict, defaultdict
+
+from edsl.jobs.interviews.InterviewStatusDictionary import InterviewStatusDictionary
+from edsl.jobs.tokens.InterviewTokenUsage import InterviewTokenUsage
+from edsl.enums import pricing, TokenPricing
+from edsl.jobs.tasks.task_status_enum import TaskStatus
+
+InterviewTokenUsageMapping = DefaultDict[str, InterviewTokenUsage]
+
+
+class InterviewStatistic(UserDict):
+    @staticmethod
+    def _format_number(number, digits=0, units=""):
+        """Format a number.
+
+        :param number: the number to format
+        :param digits: the number of digits to display
+        :param units: the units to display
+
+        Example usage:
+
+        >>> InterviewStatistic._format_number(1000, 1, "sec.")
+        '1,000.0 sec.'
+        """
+        if type(number) == str:
+            return number
+        else:
+            return f"{number:,.{digits}f}" + " " + units
+
+    @property
+    def _pretty_name(self):
+        """Return a pretty name for the statistic.
+
+        Example usage:
+
+        >>> InterviewStatistic("elapsed_time", value=100, digits=1, units="sec.").pretty_name
+        'Elapsed time'
+        """
+        return self.name.replace("_", " ").capitalize()
+
+    def __init__(
+        self,
+        name: str,
+        value: float,
+        digits: int = 0,
+        units: str = "",
+        pretty_name: str = None,
+    ):
+        """Create a new InterviewStatistic object."""
+        self.name = name
+        self.value = value
+        self.digits = digits
+        self.units = units
+        self.pretty_name = pretty_name or self._pretty_name
+
+        super().__init__(
+            {self.pretty_name: self._format_number(self.value, self.digits, self.units)}
+        )
+
+        self.raw: dict = {self.name: self.value}

edsl/jobs/interviews/InterviewStatisticsCollection.py

@@ -0,0 +1,25 @@
+from collections import UserDict
+from edsl.jobs.interviews.InterviewStatistic import InterviewStatistic
+
+
+class InterviewStatisticsCollection(UserDict):
+    """A collection of interview statistics."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.raw: dict = {}
+
+    def add_stat(self, statistic: InterviewStatistic):
+        """Add a statistic to the collection.
+
+        Each statistic is a dictionary with a single key-value pair.
+
+        Example usage:
+
+        >>> isc = InterviewStatisticsCollection()
+        >>> isc.add_stat(InterviewStatistic("elapsed_time", value=100, digits=1, units="sec."))
+        >>> isc.raw
+        {'elapsed_time': 100}
+        """
+        self.update(statistic)
+        self.raw.update(statistic.raw)

edsl/jobs/interviews/InterviewStatusDictionary.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+import json
+from collections import UserDict
+from typing import Union, Dict
+
+from edsl.jobs.tasks.task_status_enum import TaskStatus, get_enum_from_string
+
+
+class InterviewStatusDictionary(UserDict):
+    """A dictionary that keeps track of the status of all the tasks in an interview."""
+
+    def __init__(self, data: Union[Dict[TaskStatus, int], None] = None):
+        if data:
+            # checks to make sure every task status is in the enum
+            assert all([task_status in data for task_status in TaskStatus])
+            super().__init__(data)
+        else:
+            # sets all the task statuses to 0
+            d = {}
+            for task_status in TaskStatus:
+                d[task_status] = 0
+            d["number_from_cache"] = 0
+            super().__init__(d)
+
+    def __add__(
+        self, other: "InterviewStatusDictionary"
+    ) -> "InterviewStatusDictionary":
+        """Adds two InterviewStatusDictionaries together."""
+        if not isinstance(other, InterviewStatusDictionary):
+            raise ValueError(f"Can't add {type(other)} to InterviewStatusDictionary")
+        new_dict = {}
+        for key in self.keys():
+            new_dict[key] = self[key] + other[key]
+        return InterviewStatusDictionary(new_dict)
+
+    @property
+    def waiting(self) -> int:
+        """Return the number of tasks that are in a waiting status of some kind."""
+
+        waiting_status_list = [
+            TaskStatus.WAITING_FOR_REQUEST_CAPACITY,
+            TaskStatus.WAITING_FOR_TOKEN_CAPACITY,
+            TaskStatus.WAITING_FOR_DEPENDENCIES,
+        ]
+
+        return sum([self[status] for status in waiting_status_list])
+
+    def __repr__(self):
+        return f"InterviewStatusDictionary({self.data})"
+
+    def to_dict(self):
+        new_data = {str(key): value for key, value in self.data.items()}
+        return new_data
+
+    def print(self):
+        d = {}
+        for key, value in self.data.items():
+            d[str(key)] = value
+        from edsl.utilities.interface import print_dict_with_rich
+
+        print_dict_with_rich(d)
+
+    @classmethod
+    def from_dict(cls, data):
+        new_data = {get_enum_from_string(key): value for key, value in data.items()}
+        return cls(new_data)
+
+    def to_json(self):
+        import json
+
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, data):
+        import json
+
+        data = json.loads(data)
+        return cls.from_dict(data)

edsl/jobs/interviews/InterviewStatusLog.py

@@ -0,0 +1,92 @@
+from collections import UserDict
+
+from edsl.jobs.tasks.task_status_enum import TaskStatus, status_colors
+
+
+class InterviewStatusLog(UserDict):
+    """A dictionary of TaskStatusLog objects.
+
+    The key is the name of the task.
+    """
+
+    @property
+    def min_time(self):
+        return min([log.min_time for log in self.values()])
+
+    @property
+    def max_time(self):
+        return max([log.max_time for log in self.values()])
+
+    def status_matrix(self, num_periods):
+        """Return a matrix of status values."""
+        start_time = self.min_time
+        end_time = self.max_time
+        time_increment = (end_time - start_time) / num_periods
+        status_matrix = {}
+        time_periods = [start_time + i * time_increment for i in range(num_periods)]
+        for task_name, log in self.items():
+            status_matrix[task_name] = [log.status_at_time(t) for t in time_periods]
+        return status_matrix
+
+    def numerical_matrix(self, num_periods):
+        """Return a numerical matrix of status values."""
+        status_dicts = self.status_matrix(num_periods)
+
+        num_cols = num_periods
+        num_rows = len(status_dicts)
+        matrix = [[0 for _ in range(num_cols)] for _ in range(num_rows)]
+
+        for row_index, (task_name, status_list) in enumerate(status_dicts.items()):
+            matrix[row_index] = [
+                list(status_colors.keys()).index(status) for status in status_list
+            ]
+
+        index_to_names = {i: name for i, name in enumerate(status_dicts.keys())}
+        return matrix, index_to_names
+
+    def visualize(self, num_periods=10):
+        """Visualize the status matrix with outlined squares."""
+        import matplotlib.pyplot as plt
+        from matplotlib.colors import ListedColormap
+        import numpy as np
+        from matplotlib.patches import Rectangle
+
+        # Define your custom colormap
+        custom_cmap = ListedColormap(list(status_colors.values()))
+
+        # Generate the matrix
+        matrix, index_to_names = self.numerical_matrix(num_periods)
+
+        # Create the figure and axes
+        plt.figure(figsize=(10, 5))
+        ax = plt.gca()
+
+        # Display the matrix and keep a reference to the imshow object
+        im = ax.imshow(matrix, aspect="auto", cmap=custom_cmap)
+
+        # Adding color bar, now correctly associating it with 'im'
+        cbar = plt.colorbar(im, ticks=range(len(status_colors)), label="Task Status")
+
+        cbar_labels = [status.name for status in status_colors.keys()]
+        # breakpoint()
+        cbar.set_ticklabels(cbar_labels)  # Setting the custom labels for the colorbar
+
+        im.set_clim(
+            -0.5, len(status_colors) - 0.5
+        )  # Setting color limits directly on the imshow object
+
+        # Outline each cell by drawing rectangles
+        for (j, i), val in np.ndenumerate(matrix):
+            ax.add_patch(
+                Rectangle(
+                    (i - 0.5, j - 0.5), 1, 1, fill=False, edgecolor="black", lw=0.5
+                )
+            )
+
+        # Set custom y-axis ticks and labels
+        yticks = list(index_to_names.keys())
+        yticklabels = list(index_to_names.values())
+        plt.yticks(ticks=yticks, labels=yticklabels)
+
+        # Show the plot
+        plt.show()

edsl/jobs/interviews/ReportErrors.py

@@ -0,0 +1,66 @@
+import json
+import requests
+import threading
+from edsl.coop import Coop
+
+
+class ReportErrors:
+    def __init__(self, task_history):
+        self.task_history = task_history
+        self.email = None
+
+    @property
+    def data(self):
+        return {
+            "text": self.task_history.to_dict(),
+            "email": self.email,
+        }
+
+    def get_email(self, timeout=10):
+        """Helper method to get user input with a timeout."""
+        input_queue = []
+
+        def input_thread_method():
+            email_input = input(
+                "Please enter your email address (if you want us to get in touch): "
+            )
+            input_queue.append(email_input)
+
+        input_thread = threading.Thread(target=input_thread_method)
+        input_thread.start()
+        input_thread.join(timeout=timeout)
+
+        if input_queue:
+            self.email = input_queue[0]
+        else:
+            print("No input received within the timeout period.")
+
+    def upload(self):
+        # The previous implementation was removed because it relied on the old Coop ErrorModel
+        pass
+
+
+def main():
+    from edsl.jobs.interviews.ReportErrors import ReportErrors
+
+    class TaskHistory:
+        def __init__(self, data):
+            self.data = data
+
+        def to_dict(self):
+            """Converts the internal data of the task history to a dictionary format."""
+            return self.data
+
+    task_history_data = {
+        "task": "Example Task",
+        "status": "Completed",
+        "details": "This is an example of a task history.",
+    }
+    task_history = TaskHistory(task_history_data)
+
+    reporter = ReportErrors(task_history)
+    # one without email
+    reporter.upload()
+    # one with email
+    reporter.email = "fake@gmail.com"
+    reporter.upload()

edsl/jobs/interviews/interview_status_enum.py

@@ -0,0 +1,9 @@
+import enum
+
+
+class InterviewStatus(enum.Enum):
+    "These are the possible states an interview can be in."
+    NOT_STARTED = enum.auto()
+    SUCCESS = enum.auto()
+    WAITING_FOR_RESOURCES = enum.auto()
+    FAILED = enum.auto()

edsl/jobs/jobs_status_enums.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class JobsStatus(Enum):
+    QUEUED = "queued"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"

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