edsl 0.1.49__py3-none-any.whl → 0.1.51__py3-none-any.whl

edsl/dataset/file_exports.py

@@ -2,7 +2,8 @@ from abc import ABC, abstractmethod
 import io
 import csv
 import base64
-from typing import Optional, Union, Tuple, List, Any, Dict
+import sqlite3
+from typing import Optional, Union, Any, Dict
 
 
 class FileExport(ABC):
@@ -37,14 +38,15 @@ class FileExport(ABC):
         """Generate default filename for this format."""
         return f"results.{self.suffix}"
 
-    def _create_filestore(self, data: Union[str, bytes]) -> "FileStore":
+    def _create_filestore(self, data: Union[str, bytes]):
         """Create a FileStore instance with encoded data."""
+        from ..scenarios.file_store import FileStore
         if isinstance(data, str):
             base64_string = base64.b64encode(data.encode()).decode()
         else:
             base64_string = base64.b64encode(data).decode()
 
-        from edsl.scenarios import FileStore
+        # FileStore already imported
 
         path = self.filename or self._get_default_filename()
 
@@ -66,8 +68,12 @@ class FileExport(ABC):
         """Convert the input data to the target format."""
         pass
 
-    def export(self) -> Optional["FileStore"]:
-        """Export the data to a FileStore instance."""
+    def export(self) -> Optional:
+        """Export the data to a FileStore instance.
+        
+        Returns:
+            A FileStore instance or None if the file was written directly.
+        """
         formatted_data = self.format_data()
         return self._create_filestore(formatted_data)
 
@@ -140,8 +146,6 @@ class ExcelExport(TabularExport):
         return buffer.getvalue()
 
 
-import sqlite3
-from typing import Any
 
 
 class SQLiteExport(TabularExport):
@@ -195,11 +199,12 @@ class SQLiteExport(TabularExport):
             cursor.execute(f"DROP TABLE IF EXISTS {self.table_name}")
         elif self.if_exists == "fail":
             cursor.execute(
-                f"SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+                "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
                 (self.table_name,),
             )
             if cursor.fetchone():
-                raise ValueError(f"Table {self.table_name} already exists")
+                from .exceptions import DatasetValueError
+                raise DatasetValueError(f"Table {self.table_name} already exists")
 
         # Create table
         columns = ", ".join(f'"{col}" {dtype}' for col, dtype in column_types)
@@ -240,12 +245,14 @@ class SQLiteExport(TabularExport):
         """Validate initialization parameters."""
         valid_if_exists = {"fail", "replace", "append"}
         if self.if_exists not in valid_if_exists:
-            raise ValueError(
+            from .exceptions import DatasetValueError
+            raise DatasetValueError(
                 f"if_exists must be one of {valid_if_exists}, got {self.if_exists}"
             )
 
         # Validate table name (basic SQLite identifier validation)
         if not self.table_name.isalnum() and not all(c in "_" for c in self.table_name):
-            raise ValueError(
+            from .exceptions import DatasetValueError
+            raise DatasetValueError(
                 f"Invalid table name: {self.table_name}. Must contain only alphanumeric characters and underscores."
             )

edsl/dataset/r/ggplot.py

@@ -30,11 +30,13 @@ class GGPlot:
 
         if result.returncode != 0:
             if result.returncode == 127:
-                raise RuntimeError(
+                from ..exceptions import DatasetRuntimeError
+                raise DatasetRuntimeError(
                     "Rscript is probably not installed. Please install R from https://cran.r-project.org/"
                 )
             else:
-                raise RuntimeError(
+                from ..exceptions import DatasetRuntimeError
+                raise DatasetRuntimeError(
                     f"An error occurred while running Rscript: {result.stderr}"
                 )
 
@@ -47,7 +49,8 @@ class GGPlot:
         """Save the plot to a file."""
         format = filename.split('.')[-1].lower()
         if format not in ['svg', 'png']:
-            raise ValueError("Only 'svg' and 'png' formats are supported")
+            from ..exceptions import DatasetValueError
+            raise DatasetValueError("Only 'svg' and 'png' formats are supported")
             
         save_command = f'\nggsave("{filename}", plot = last_plot(), width = {self.width}, height = {self.height}, device = "{format}")'
         self._execute_r_code(save_command)
@@ -62,7 +65,6 @@ class GGPlot:
         if self._saved:
             return None
             
-        import tempfile
         
         # Generate SVG if we haven't already
         if self._svg_data is None:
@@ -77,7 +79,12 @@ class GGPlot:
 
 class GGPlotMethod:
 
-    def __init__(self, results: 'Results'):
+    def __init__(self, results):
+        """Initialize the GGPlotMethod with results.
+        
+        Args:
+            results: A Results or Dataset object.
+        """
         self.results = results
     
     """Mixin class for ggplot2 plotting."""
@@ -106,7 +113,7 @@ class GGPlotMethod:
         :param width: The width of the plot in inches.
         :param factor_orders: A dictionary of factor columns and their order.
         """
-        if sql == None:
+        if sql is None:
             sql = "select * from self"
 
         if shape == "long":

edsl/display/__init__.py

@@ -0,0 +1,27 @@
+"""
+Display module for edsl providing IPython display functionality with plugin capabilities.
+
+This module provides abstractions over IPython.display functionality to facilitate
+greater modularity and potentially make the IPython dependency optional via a plugin system.
+"""
+
+from .core import display, HTML, FileLink, IFrame, is_notebook_environment
+from .utils import file_notice, display_html
+from .plugin import DisplayPlugin, DisplayPluginRegistry
+
+__all__ = [
+    # Core display functionality
+    "display",
+    "HTML",
+    "FileLink",
+    "IFrame",
+    "is_notebook_environment",
+    
+    # Utility functions
+    "file_notice",
+    "display_html",
+    
+    # Plugin architecture
+    "DisplayPlugin",
+    "DisplayPluginRegistry"
+]

edsl/display/core.py

@@ -0,0 +1,147 @@
+"""
+Core display functionality that abstracts IPython.display.
+
+This module provides wrapper classes and functions that abstract the IPython.display
+functionality to enable potential future replacement with alternative implementations.
+"""
+
+try:
+    from IPython.display import display as ipython_display
+    from IPython.display import HTML as IPythonHTML
+    from IPython.display import FileLink as IPythonFileLink
+    from IPython.display import IFrame as IPythonIFrame
+    _IPYTHON_AVAILABLE = True
+except ImportError:
+    _IPYTHON_AVAILABLE = False
+
+
+def is_notebook_environment():
+    """
+    Check if code is running in a Jupyter notebook or similar interactive environment.
+    
+    Returns:
+        bool: True if running in a notebook environment, False otherwise
+    """
+    try:
+        shell = get_ipython().__class__.__name__
+        if shell == "ZMQInteractiveShell":
+            return True  # Jupyter notebook or qtconsole
+        elif shell == "Shell":  # Google Colab's shell class
+            import sys
+            if "google.colab" in sys.modules:
+                return True  # Running in Google Colab
+            return False
+        elif shell == "TerminalInteractiveShell":
+            return False  # Terminal running IPython
+        else:
+            return False  # Other type
+    except (NameError, ImportError):
+        return False  # Probably standard Python interpreter
+
+
+class HTML:
+    """
+    Wrapper for IPython's HTML display class.
+    
+    This class provides the same functionality as IPython.display.HTML but can be
+    extended or replaced with alternative implementations.
+    """
+    def __init__(self, data=None, metadata=None, **kwargs):
+        self.data = data
+        self.metadata = metadata
+        self.kwargs = kwargs
+        
+        if _IPYTHON_AVAILABLE and is_notebook_environment():
+            self._ipython_html = IPythonHTML(data, metadata, **kwargs)
+        else:
+            self._ipython_html = None
+
+    def __repr__(self):
+        """Return a string representation of the HTML object."""
+        return f"{self.data}"
+
+    def _repr_html_(self):
+        """Return HTML representation of the object."""
+        if self._ipython_html:
+            return self._ipython_html._repr_html_()
+        return self.data
+
+
+class FileLink:
+    """
+    Wrapper for IPython's FileLink display class.
+    
+    This class provides the same functionality as IPython.display.FileLink but can be
+    extended or replaced with alternative implementations.
+    """
+    def __init__(self, path, url_prefix='', result_html_prefix='', result_html_suffix='', **kwargs):
+        self.path = path
+        self.url_prefix = url_prefix
+        self.result_html_prefix = result_html_prefix 
+        self.result_html_suffix = result_html_suffix
+        self.kwargs = kwargs
+        
+        if _IPYTHON_AVAILABLE and is_notebook_environment():
+            self._ipython_filelink = IPythonFileLink(
+                path, 
+                url_prefix, 
+                result_html_prefix, 
+                result_html_suffix,
+                **kwargs
+            )
+        else:
+            self._ipython_filelink = None
+
+    def _repr_html_(self):
+        """Return HTML representation of the file link."""
+        if self._ipython_filelink:
+            return self._ipython_filelink._repr_html_()
+        return f'<a href="{self.url_prefix}{self.path}" target="_blank">{self.path}</a>'
+
+
+class IFrame:
+    """
+    Wrapper for IPython's IFrame display class.
+    
+    This class provides the same functionality as IPython.display.IFrame but can be
+    extended or replaced with alternative implementations.
+    """
+    def __init__(self, src, width, height, **kwargs):
+        self.src = src
+        self.width = width
+        self.height = height
+        self.kwargs = kwargs
+        
+        if _IPYTHON_AVAILABLE and is_notebook_environment():
+            self._ipython_iframe = IPythonIFrame(src, width, height, **kwargs)
+        else:
+            self._ipython_iframe = None
+
+    def _repr_html_(self):
+        """Return HTML representation of the iframe."""
+        if self._ipython_iframe:
+            return self._ipython_iframe._repr_html_()
+        return f'<iframe src="{self.src}" width="{self.width}" height="{self.height}"></iframe>'
+
+
+def display(obj, *args, **kwargs):
+    """
+    Display an object in the frontend.
+    
+    Wrapper around IPython.display.display that can be extended or replaced with
+    alternative implementations.
+    
+    Args:
+        obj: The object to display
+        *args: Additional objects to display
+        **kwargs: Additional keyword arguments for display
+    """
+    if _IPYTHON_AVAILABLE and is_notebook_environment():
+        ipython_display(obj, *args, **kwargs)
+    else:
+        # Fallback behavior when not in notebook environment
+        if hasattr(obj, '_repr_html_'):
+            print("HTML representation available, but not in notebook environment.")
+        print(repr(obj))
+        for arg in args:
+            print(repr(arg))

edsl/display/plugin.py

@@ -0,0 +1,189 @@
+"""
+Plugin architecture for the display module.
+
+This module defines the interface for display plugins and provides the mechanism
+for registering and using them. Plugins enable replacing the default IPython-based
+display functionality with alternative implementations.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Type, List
+
+
+class DisplayPlugin(ABC):
+    """
+    Abstract base class for display plugins.
+    
+    Any plugin for providing display functionality must implement this interface.
+    """
+    
+    @abstractmethod
+    def display(self, obj, *args, **kwargs) -> None:
+        """
+        Display an object in the frontend.
+        
+        Args:
+            obj: The object to display
+            *args: Additional objects to display
+            **kwargs: Additional keyword arguments for display
+        """
+        pass
+    
+    @abstractmethod
+    def html(self, data=None, metadata=None, **kwargs) -> Any:
+        """
+        Create an HTML display object.
+        
+        Args:
+            data: The HTML data to display
+            metadata: Any metadata for the display object
+            **kwargs: Additional keyword arguments
+            
+        Returns:
+            An object that can be displayed
+        """
+        pass
+    
+    @abstractmethod
+    def file_link(self, path, url_prefix='', result_html_prefix='', 
+                 result_html_suffix='', **kwargs) -> Any:
+        """
+        Create a FileLink display object.
+        
+        Args:
+            path: The path to the file
+            url_prefix: Prefix for the URL
+            result_html_prefix: Prefix for the HTML result
+            result_html_suffix: Suffix for the HTML result
+            **kwargs: Additional keyword arguments
+            
+        Returns:
+            An object that can be displayed
+        """
+        pass
+    
+    @abstractmethod
+    def iframe(self, src, width, height, **kwargs) -> Any:
+        """
+        Create an IFrame display object.
+        
+        Args:
+            src: The source URL for the iframe
+            width: The width of the iframe
+            height: The height of the iframe
+            **kwargs: Additional keyword arguments
+            
+        Returns:
+            An object that can be displayed
+        """
+        pass
+    
+    @abstractmethod
+    def is_supported_environment(self) -> bool:
+        """
+        Check if the current environment supports this display plugin.
+        
+        Returns:
+            bool: True if the environment is supported, False otherwise
+        """
+        pass
+
+
+class DisplayPluginRegistry:
+    """
+    Registry for display plugins.
+    
+    This registry maintains a list of available display plugins and provides
+    a mechanism for selecting the appropriate plugin for the current environment.
+    """
+    
+    _plugins: List[Type[DisplayPlugin]] = []
+    _active_plugin: Optional[DisplayPlugin] = None
+    
+    @classmethod
+    def register_plugin(cls, plugin_class: Type[DisplayPlugin]) -> None:
+        """
+        Register a display plugin.
+        
+        Args:
+            plugin_class: The plugin class to register
+        """
+        if plugin_class not in cls._plugins:
+            cls._plugins.append(plugin_class)
+    
+    @classmethod
+    def get_active_plugin(cls) -> Optional[DisplayPlugin]:
+        """
+        Get the currently active display plugin.
+        
+        If no plugin is active, this method will initialize the first supported plugin.
+        
+        Returns:
+            The active display plugin, or None if no plugins are available
+        """
+        if cls._active_plugin is None:
+            for plugin_class in cls._plugins:
+                plugin = plugin_class()
+                if plugin.is_supported_environment():
+                    cls._active_plugin = plugin
+                    break
+        
+        return cls._active_plugin
+    
+    @classmethod
+    def set_active_plugin(cls, plugin: DisplayPlugin) -> None:
+        """
+        Set the active display plugin.
+        
+        Args:
+            plugin: The plugin instance to set as active
+        """
+        cls._active_plugin = plugin
+
+
+# Define a default IPython plugin that will be registered by default
+class IPythonDisplayPlugin(DisplayPlugin):
+    """
+    Default display plugin that uses IPython.display.
+    """
+    
+    def display(self, obj, *args, **kwargs) -> None:
+        """
+        Display an object using IPython.display.display.
+        """
+        from .core import display as core_display
+        core_display(obj, *args, **kwargs)
+    
+    def html(self, data=None, metadata=None, **kwargs) -> Any:
+        """
+        Create an HTML display object using IPython.display.HTML.
+        """
+        from .core import HTML
+        return HTML(data, metadata, **kwargs)
+    
+    def file_link(self, path, url_prefix='', result_html_prefix='', 
+                 result_html_suffix='', **kwargs) -> Any:
+        """
+        Create a FileLink display object using IPython.display.FileLink.
+        """
+        from .core import FileLink
+        return FileLink(path, url_prefix, result_html_prefix, 
+                       result_html_suffix, **kwargs)
+    
+    def iframe(self, src, width, height, **kwargs) -> Any:
+        """
+        Create an IFrame display object using IPython.display.IFrame.
+        """
+        from .core import IFrame
+        return IFrame(src, width, height, **kwargs)
+    
+    def is_supported_environment(self) -> bool:
+        """
+        Check if IPython display functionality is available.
+        """
+        from .core import _IPYTHON_AVAILABLE, is_notebook_environment
+        return _IPYTHON_AVAILABLE and is_notebook_environment()
+
+
+# Register the default IPython plugin
+DisplayPluginRegistry.register_plugin(IPythonDisplayPlugin)

edsl/display/utils.py

@@ -0,0 +1,52 @@
+"""
+Utility functions for display-related operations.
+
+This module provides helper functions that build on the core display functionality
+to perform common display-related tasks used throughout the edsl package.
+"""
+
+from .core import HTML, display, is_notebook_environment
+
+
+def file_notice(file_name, link_text="Download file"):
+    """
+    Display a notice about a file being created, with a download link in notebook environments.
+    
+    Args:
+        file_name (str): The path to the file
+        link_text (str): The text to display for the download link
+        
+    Returns:
+        None
+    """
+    if is_notebook_environment():
+        html_content = f'<p>File created: {file_name}</p><a href="{file_name}" download>{link_text}</a>'
+        display(HTML(html_content))
+    else:
+        print(f"File created: {file_name}")
+
+
+def display_html(html_content, width=None, height=None, as_iframe=False):
+    """
+    Display HTML content, optionally within an iframe.
+    
+    Args:
+        html_content (str): The HTML content to display
+        width (int, optional): Width of the iframe (if as_iframe=True)
+        height (int, optional): Height of the iframe (if as_iframe=True)
+        as_iframe (bool): Whether to display the content in an iframe
+        
+    Returns:
+        None
+    """
+    from html import escape
+    
+    if as_iframe:
+        
+        width = width or 600
+        height = height or 200
+        escaped_output = escape(html_content)
+        iframe_html = f'<iframe srcdoc="{escaped_output}" style="width: {width}px; height: {height}px;"></iframe>'
+        display(HTML(iframe_html))
+    else:
+        display(HTML(html_content))

edsl/inference_services/__init__.py

@@ -2,4 +2,12 @@ from .inference_services_collection import InferenceServicesCollection
 from .registry import default
 from .inference_service_abc import InferenceServiceABC
 from .data_structures import AvailableModels
-from .exceptions import InferenceServiceError
+from .exceptions import InferenceServiceError
+
+__all__ = [
+    "InferenceServicesCollection",
+    "default",
+    "InferenceServiceABC",
+    "AvailableModels",
+    "InferenceServiceError"
+]

edsl/inference_services/available_model_cache_handler.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, get_args, Union
+from typing import List, Optional, Union
 from pathlib import Path
 import sqlite3
 from datetime import datetime

edsl/inference_services/available_model_fetcher.py

@@ -1,6 +1,5 @@
-from typing import Any, List, Tuple, Optional, Dict, TYPE_CHECKING, Union, Generator
+from typing import List, Tuple, Optional, Dict, Union
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from collections import UserList
 
 from .service_availability import ServiceAvailability
 from .inference_service_abc import InferenceServiceABC
@@ -56,7 +55,7 @@ class AvailableModelFetcher:
 
         :param service: Optional[InferenceServiceABC] - If specified, only fetch models for this service.
 
-        >>> from edsl.inference_services.services.open_ai_service import OpenAIService
+        >>> from .services.open_ai_service import OpenAIService
         >>> af = AvailableModelFetcher([OpenAIService()], {})
         >>> af.available(service="openai")
         [LanguageModelInfo(model_name='...', service_name='openai'), ...]
@@ -156,7 +155,8 @@ class AvailableModelFetcher:
         """The service name is the _inference_service_ attribute of the service."""
         if service_name in self._service_map:
             return self._service_map[service_name]
-        raise ValueError(f"Service {service_name} not found")
+        from .exceptions import InferenceServiceValueError
+        raise InferenceServiceValueError(f"Service {service_name} not found")
 
     def _get_all_models(self, force_refresh=False) -> List[LanguageModelInfo]:
         all_models = []
@@ -191,8 +191,7 @@ class AvailableModelFetcher:
 def main():
     from .services.open_ai_service import OpenAIService
 
-    af = AvailableModelFetcher([OpenAIService()], {}, verbose=True)
-    # print(af.available(service="openai"))
+    # Create fetcher without assigning to unused variable
     all_models = AvailableModelFetcher([OpenAIService()], {})._get_all_models(
         force_refresh=True
     )

edsl/inference_services/data_structures.py

@@ -1,9 +1,8 @@
 from collections import UserDict, defaultdict, UserList
-from typing import Union, Optional, List
+from typing import Optional, List
 from dataclasses import dataclass
 
 from ..enums import InferenceServiceLiteral
-from ..scenarios import ScenarioList
 
 @dataclass
 class LanguageModelInfo:
@@ -44,7 +43,8 @@ class LanguageModelInfo:
         elif key == 1:
             return self.service_name
         else:
-            raise IndexError("Index out of range")
+            from .exceptions import InferenceServiceIndexError
+            raise InferenceServiceIndexError("Index out of range")
 
     @classmethod
     def example(cls) -> "LanguageModelInfo":
@@ -70,7 +70,7 @@ class AvailableModels(UserList):
         return self.to_dataset().print()
 
     def to_dataset(self):
-        from edsl.scenarios.ScenarioList import ScenarioList
+        from ..scenarios.scenario_list import ScenarioList
 
         models, services = zip(
             *[(model.model_name, model.service_name) for model in self]
@@ -106,13 +106,15 @@ class AvailableModels(UserList):
                 ]
             )
             if len(avm) == 0:
-                raise ValueError(
+                from .exceptions import InferenceServiceValueError
+                raise InferenceServiceValueError(
                     "No models found matching the search pattern: " + pattern
                 )
             else:
                 return avm
         except re.error as e:
-            raise ValueError(f"Invalid regular expression pattern: {e}")
+            from .exceptions import InferenceServiceValueError
+            raise InferenceServiceValueError(f"Invalid regular expression pattern: {e}")
 
 
 class ServiceToModelsMapping(UserDict):
@@ -126,7 +128,8 @@ class ServiceToModelsMapping(UserDict):
     def _validate_service_names(self):
         for service in self.service_names:
             if service not in InferenceServiceLiteral:
-                raise ValueError(f"Invalid service name: {service}")
+                from .exceptions import InferenceServiceValueError
+                raise InferenceServiceValueError(f"Invalid service name: {service}")
 
     def model_to_services(self) -> dict:
         self._model_to_service = defaultdict(list)