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

edsl/jobs/data_structures.py

@@ -1,120 +0,0 @@
-from typing import Optional, Literal
-from dataclasses import dataclass, asdict
-
-# from edsl.data_transfer_models import VisibilityType
-from edsl.data.Cache import Cache
-from edsl.jobs.buckets.BucketCollection import BucketCollection
-from edsl.language_models.key_management.KeyLookup import KeyLookup
-from edsl.jobs.runners.JobsRunnerStatus import JobsRunnerStatus
-
-VisibilityType = Literal["private", "public", "unlisted"]
-from edsl.Base import Base
-
-
-@dataclass
-class RunEnvironment:
-    cache: Optional[Cache] = None
-    bucket_collection: Optional[BucketCollection] = None
-    key_lookup: Optional[KeyLookup] = None
-    jobs_runner_status: Optional["JobsRunnerStatus"] = None
-
-
-@dataclass
-class RunParameters(Base):
-    n: int = 1
-    progress_bar: bool = False
-    stop_on_exception: bool = False
-    check_api_keys: bool = False
-    verbose: bool = True
-    print_exceptions: bool = True
-    remote_cache_description: Optional[str] = None
-    remote_inference_description: Optional[str] = None
-    remote_inference_results_visibility: Optional[VisibilityType] = "unlisted"
-    skip_retry: bool = False
-    raise_validation_errors: bool = False
-    disable_remote_cache: bool = False
-    disable_remote_inference: bool = False
-    job_uuid: Optional[str] = None
-
-    def to_dict(self, add_edsl_version=False) -> dict:
-        d = asdict(self)
-        if add_edsl_version:
-            from edsl import __version__
-
-            d["edsl_version"] = __version__
-            d["edsl_class_name"] = "RunConfig"
-        return d
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "RunConfig":
-        return cls(**data)
-
-    def code(self):
-        return f"RunConfig(**{self.to_dict()})"
-
-    @classmethod
-    def example(cls) -> "RunConfig":
-        return cls()
-
-
-@dataclass
-class RunConfig:
-    environment: RunEnvironment
-    parameters: RunParameters
-
-    def add_environment(self, environment: RunEnvironment):
-        self.environment = environment
-
-    def add_bucket_collection(self, bucket_collection: BucketCollection):
-        self.environment.bucket_collection = bucket_collection
-
-    def add_cache(self, cache: Cache):
-        self.environment.cache = cache
-
-    def add_key_lookup(self, key_lookup: KeyLookup):
-        self.environment.key_lookup = key_lookup
-
-
-"""This module contains the Answers class, which is a helper class to hold the answers to a survey."""
-
-from collections import UserDict
-from edsl.data_transfer_models import EDSLResultObjectInput
-
-
-class Answers(UserDict):
-    """Helper class to hold the answers to a survey."""
-
-    def add_answer(
-        self, response: EDSLResultObjectInput, question: "QuestionBase"
-    ) -> None:
-        """Add a response to the answers dictionary."""
-        answer = response.answer
-        comment = response.comment
-        generated_tokens = response.generated_tokens
-        # record the answer
-        if generated_tokens:
-            self[question.question_name + "_generated_tokens"] = generated_tokens
-        self[question.question_name] = answer
-        if comment:
-            self[question.question_name + "_comment"] = comment
-
-    def replace_missing_answers_with_none(self, survey: "Survey") -> None:
-        """Replace missing answers with None. Answers can be missing if the agent skips a question."""
-        for question_name in survey.question_names:
-            if question_name not in self:
-                self[question_name] = None
-
-    def to_dict(self):
-        """Return a dictionary of the answers."""
-        return self.data
-
-    @classmethod
-    def from_dict(cls, d):
-        """Return an Answers object from a dictionary."""
-        return cls(d)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/jobs/decorators.py

@@ -1,35 +0,0 @@
-from functools import wraps
-from threading import RLock
-import inspect
-
-
-def synchronized_class(wrapped_class):
-    """Class decorator that makes all methods thread-safe."""
-
-    # Add a lock to the class
-    setattr(wrapped_class, "_lock", RLock())
-
-    # Get all methods from the class
-    for name, method in inspect.getmembers(wrapped_class, inspect.isfunction):
-        # Skip magic methods except __getitem__, __setitem__, __delitem__
-        if name.startswith("__") and name not in [
-            "__getitem__",
-            "__setitem__",
-            "__delitem__",
-        ]:
-            continue
-
-        # Create synchronized version of the method
-        def create_synchronized_method(method):
-            @wraps(method)
-            def synchronized_method(*args, **kwargs):
-                instance = args[0]  # first arg is self
-                with instance._lock:
-                    return method(*args, **kwargs)
-
-            return synchronized_method
-
-        # Replace the original method with synchronized version
-        setattr(wrapped_class, name, create_synchronized_method(method))
-
-    return wrapped_class

edsl/jobs/jobs_status_enums.py

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

edsl/jobs/loggers/HTMLTableJobLogger.py

@@ -1,304 +0,0 @@
-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/results_exceptions_handler.py

@@ -1,98 +0,0 @@
-from typing import Optional, TYPE_CHECKING, Protocol
-import sys
-from edsl.scenarios.FileStore import HTMLFileStore
-from edsl.config import CONFIG
-from edsl.coop.coop import Coop
-
-
-class ResultsProtocol(Protocol):
-    """Protocol defining the required interface for Results objects."""
-
-    @property
-    def has_unfixed_exceptions(self) -> bool: ...
-
-    @property
-    def task_history(self) -> "TaskHistoryProtocol": ...
-
-
-class TaskHistoryProtocol(Protocol):
-    """Protocol defining the required interface for TaskHistory objects."""
-
-    @property
-    def indices(self) -> list: ...
-
-    def html(self, cta: str, open_in_browser: bool, return_link: bool) -> str: ...
-
-
-class RunParametersProtocol(Protocol):
-    """Protocol defining the required interface for RunParameters objects."""
-
-    @property
-    def print_exceptions(self) -> bool: ...
-
-
-class ResultsExceptionsHandler:
-    """Handles exception reporting and display functionality."""
-
-    def __init__(
-        self, results: ResultsProtocol, parameters: RunParametersProtocol
-    ) -> None:
-        self.results = results
-        self.parameters = parameters
-
-        self.open_in_browser = self._get_browser_setting()
-        self.remote_logging = self._get_remote_logging_setting()
-
-    def _get_browser_setting(self) -> bool:
-        """Determine if exceptions should be opened in browser based on config."""
-        setting = CONFIG.get("EDSL_OPEN_EXCEPTION_REPORT_URL")
-        if setting == "True":
-            return True
-        elif setting == "False":
-            return False
-        else:
-            raise Exception(
-                "EDSL_OPEN_EXCEPTION_REPORT_URL must be either True or False"
-            )
-
-    def _get_remote_logging_setting(self) -> bool:
-        """Get remote logging setting from coop."""
-        try:
-            coop = Coop()
-            return coop.edsl_settings["remote_logging"]
-        except Exception as e:
-            # print(e)
-            return False
-
-    def _generate_error_message(self, indices) -> str:
-        """Generate appropriate error message based on number of exceptions."""
-        msg = f"Exceptions were raised in {len(indices)} interviews.\n"
-        if len(indices) > 5:
-            msg += f"Exceptions were raised in the following interviews: {indices}.\n"
-        return msg
-
-    def handle_exceptions(self) -> None:
-        """Handle exceptions by printing messages and generating reports as needed."""
-        if not (
-            self.results.has_unfixed_exceptions and self.parameters.print_exceptions
-        ):
-            return
-
-        # Print error message
-        error_msg = self._generate_error_message(self.results.task_history.indices)
-        print(error_msg, file=sys.stderr)
-
-        # Generate HTML report
-        filepath = self.results.task_history.html(
-            cta="Open report to see details.",
-            open_in_browser=self.open_in_browser,
-            return_link=True,
-        )
-
-        # Handle remote logging if enabled
-        if self.remote_logging:
-            filestore = HTMLFileStore(filepath)
-            coop_details = filestore.push(description="Error report")
-            print(coop_details)
-
-        print("Also see: https://docs.expectedparrot.com/en/latest/exceptions.html")

edsl/language_models/ComputeCost.py

@@ -1,63 +0,0 @@
-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