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

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/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

edsl/language_models/PriceManager.py

@@ -1,127 +0,0 @@
-from typing import Dict, Tuple, Optional, Union
-
-
-class PriceManager:
-    _instance = None
-    _price_lookup: Dict[Tuple[str, str], Dict] = {}
-    _is_initialized = False
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(PriceManager, cls).__new__(cls)
-        return cls._instance
-
-    def __init__(self):
-        # Only initialize once, even if __init__ is called multiple times
-        if not self._is_initialized:
-            self._is_initialized = True
-            self.refresh_prices()
-
-    def refresh_prices(self) -> None:
-        """
-        Fetch fresh prices from the Coop service and update the internal price lookup.
-
-        """
-        from edsl.coop import Coop
-
-        c = Coop()
-        try:
-            self._price_lookup = c.fetch_prices()
-        except Exception as e:
-            print(f"Error fetching prices: {str(e)}")
-
-    def get_price(self, inference_service: str, model: str) -> Optional[Dict]:
-        """
-        Get the price information for a specific service and model combination.
-
-        Args:
-            inference_service (str): The name of the inference service
-            model (str): The model identifier
-
-        Returns:
-            Optional[Dict]: Price information if found, None otherwise
-        """
-        key = (inference_service, model)
-        return self._price_lookup.get(key)
-
-    def get_all_prices(self) -> Dict[Tuple[str, str], Dict]:
-        """
-        Get the complete price lookup dictionary.
-
-        Returns:
-            Dict[Tuple[str, str], Dict]: The complete price lookup dictionary
-        """
-        return self._price_lookup.copy()
-
-    def calculate_cost(
-        self,
-        inference_service: str,
-        model: str,
-        usage: Dict[str, Union[str, int]],
-        input_token_name: str,
-        output_token_name: str,
-    ) -> Union[float, str]:
-        """
-        Calculate the total cost for a model usage based on input and output tokens.
-
-        Args:
-            inference_service (str): The inference service identifier
-            model (str): The model identifier
-            usage (Dict[str, Union[str, int]]): Dictionary containing token usage information
-            input_token_name (str): Key name for input tokens in the usage dict
-            output_token_name (str): Key name for output tokens in the usage dict
-
-        Returns:
-            Union[float, str]: Total cost if calculation successful, error message string if not
-        """
-        relevant_prices = self.get_price(inference_service, model)
-        if relevant_prices is None:
-            return f"Could not find price for model {model} in the price lookup."
-
-        # Extract token counts
-        try:
-            input_tokens = int(usage[input_token_name])
-            output_tokens = int(usage[output_token_name])
-        except Exception as e:
-            return f"Could not fetch tokens from model response: {e}"
-
-        # Extract price information
-        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}"
-
-        # Calculate input cost
-        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}."
-
-        # Calculate output cost
-        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
-
-    @property
-    def is_initialized(self) -> bool:
-        """
-        Check if the PriceManager has been initialized.
-
-        Returns:
-            bool: True if initialized, False otherwise
-        """
-        return self._is_initialized

edsl/language_models/RawResponseHandler.py

@@ -1,106 +0,0 @@
-import json
-from typing import Optional, Any, List
-from edsl.exceptions.language_models import LanguageModelBadResponseError
-
-from json_repair import repair_json
-
-
-def _extract_item_from_raw_response(data, sequence):
-    if isinstance(data, str):
-        try:
-            data = json.loads(data)
-        except json.JSONDecodeError as e:
-            return data
-    current_data = data
-    for i, key in enumerate(sequence):
-        try:
-            if isinstance(current_data, (list, tuple)):
-                if not isinstance(key, int):
-                    raise TypeError(
-                        f"Expected integer index for sequence at position {i}, got {type(key).__name__}"
-                    )
-                if key < 0 or key >= len(current_data):
-                    raise IndexError(
-                        f"Index {key} out of range for sequence of length {len(current_data)} at position {i}"
-                    )
-            elif isinstance(current_data, dict):
-                if key not in current_data:
-                    raise KeyError(
-                        f"Key '{key}' not found in dictionary at position {i}"
-                    )
-            else:
-                raise TypeError(
-                    f"Cannot index into {type(current_data).__name__} at position {i}. Full response is: {data} of type {type(data)}. Key sequence is: {sequence}"
-                )
-
-            current_data = current_data[key]
-        except Exception as e:
-            path = " -> ".join(map(str, sequence[: i + 1]))
-            if "error" in data:
-                msg = data["error"]
-            else:
-                msg = f"Error accessing path: {path}. {str(e)}. Full response is: '{data}'"
-            raise LanguageModelBadResponseError(message=msg, response_json=data)
-    if isinstance(current_data, str):
-        return current_data.strip()
-    else:
-        return current_data
-
-
-class RawResponseHandler:
-    """Class to handle raw responses from language models."""
-
-    def __init__(self, key_sequence: list, usage_sequence: Optional[list] = None):
-        self.key_sequence = key_sequence
-        self.usage_sequence = usage_sequence
-
-    def get_generated_token_string(self, raw_response):
-        return _extract_item_from_raw_response(raw_response, self.key_sequence)
-
-    def get_usage_dict(self, raw_response):
-        if self.usage_sequence is None:
-            return {}
-        return _extract_item_from_raw_response(raw_response, self.usage_sequence)
-
-    def parse_response(self, raw_response: dict[str, Any]) -> "EDSLOutput":
-        """Parses the API response and returns the response text."""
-
-        from edsl.data_transfer_models import EDSLOutput
-
-        generated_token_string = self.get_generated_token_string(raw_response)
-        last_newline = generated_token_string.rfind("\n")
-
-        if last_newline == -1:
-            # There is no comment
-            edsl_dict = {
-                "answer": self.convert_answer(generated_token_string),
-                "generated_tokens": generated_token_string,
-                "comment": None,
-            }
-        else:
-            edsl_dict = {
-                "answer": self.convert_answer(generated_token_string[:last_newline]),
-                "comment": generated_token_string[last_newline + 1 :].strip(),
-                "generated_tokens": generated_token_string,
-            }
-        return EDSLOutput(**edsl_dict)
-
-    @staticmethod
-    def convert_answer(response_part):
-        import json
-
-        response_part = response_part.strip()
-
-        if response_part == "None":
-            return None
-
-        repaired = repair_json(response_part)
-        if repaired == '""':
-            # it was a literal string
-            return response_part
-
-        try:
-            return json.loads(repaired)
-        except json.JSONDecodeError as j:
-            # last resort
-            return response_part

edsl/language_models/key_management/KeyLookup.py

@@ -1,63 +0,0 @@
-from collections import UserDict
-from dataclasses import asdict
-from edsl.enums import service_to_api_keyname
-
-from edsl.language_models.key_management.models import LanguageModelInput
-
-
-class KeyLookup(UserDict):
-    """A class for looking up API keys and related configuration.
-
-    >>> from edsl.language_models.key_management.models import LanguageModelInput
-    >>> lookup = KeyLookup()
-    >>> lm_input = LanguageModelInput.example()
-    >>> lookup['test'] = lm_input
-    >>> lookup.to_dict()['test']['api_token']
-    'sk-abcd123'
-    >>> restored = KeyLookup.from_dict(lookup.to_dict())
-    >>> restored['test'].api_token
-    'sk-abcd123'
-    """
-
-    def to_dict(self):
-        """
-        >>> kl = KeyLookup.example()
-        >>> kl2 = KeyLookup.from_dict(kl.to_dict())
-        >>> kl2 == kl
-        True
-        >>> kl2 is kl
-        False
-        """
-        return {k: asdict(v) for k, v in self.data.items()}
-
-    @classmethod
-    def from_dict(cls, d):
-        return cls({k: LanguageModelInput(**v) for k, v in d.items()})
-
-    @classmethod
-    def example(cls):
-        return cls(
-            {
-                "test": LanguageModelInput.example(),
-                "openai": LanguageModelInput.example(),
-            }
-        )
-
-    def to_dot_env(self):
-        """Return a string representation of the key lookup collection for a .env file."""
-        lines = []
-        for service, lm_input in self.items():
-            if service != "test":
-                lines.append(f"EDSL_SERVICE_RPM_{service.upper()}={lm_input.rpm}")
-                lines.append(f"EDSL_SERVICE_TPM_{service.upper()}={lm_input.tpm}")
-                key_name = service_to_api_keyname.get(service, service)
-                lines.append(f"{key_name.upper()}={lm_input.api_token}")
-                if lm_input.api_id is not None:
-                    lines.append(f"{service.upper()}_API_ID={lm_input.api_id}")
-        return "\n".join([f"{line}" for line in lines])
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)