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

edsl/load_plugins.py

@@ -0,0 +1,69 @@
+import logging
+
+def load_plugins():
+    """
+    Load plugins for EDSL.
+    
+    This function handles the discovery and loading of plugins via the pluggy library.
+    It searches for entry points registered under the "edsl" namespace.
+    """
+    logger = logging.getLogger("edsl")
+    
+    try:
+        logger.info("Loading plugins")
+        import pluggy
+        import pkg_resources
+        
+        logger.info("Available edsl entrypoints: %s", [ep for ep in pkg_resources.iter_entry_points("edsl")])
+        
+        # Import hook specs from the plugin system
+        from edsl.plugins.hookspec import EDSLPluginSpec
+        
+        # Create plugin manager and register specs
+        pm = pluggy.PluginManager("edsl")
+        pm.add_hookspecs(EDSLPluginSpec)
+        
+        # Load all plugins
+        logger.info("Loading setuptools entrypoints...")
+        pm.load_setuptools_entrypoints("edsl")
+        
+        # Get registered plugins 
+        registered_plugins = [
+            plugin_name 
+            for plugin_name, _ in pm.list_name_plugin()
+            if plugin_name != "EDSLHookSpecs"
+        ]
+        logger.info("Registered plugins: %s", registered_plugins)
+        
+        # Get plugins and add to __all__
+        logger.info("Calling edsl_plugin hook...")
+        try:
+            results = pm.hook.edsl_plugin()
+            logger.info("Results: %s", results)
+            plugins = {}
+            
+            if results:
+                for plugin in results:
+                    if hasattr(plugin, "__name__"):
+                        plugin_name = plugin.__name__
+                    elif hasattr(plugin, "__class__"):
+                        plugin_name = plugin.__class__.__name__
+                    else:
+                        plugin_name = f"Plugin_{len(plugins)}"
+                    
+                    logger.info(f"Loaded plugin: {plugin_name}")
+                    plugins[plugin_name] = plugin
+                
+                return plugins
+        except Exception as e:
+            logger.error("Error calling edsl_plugin hook: %s", e)
+    except ImportError as e:
+        # pluggy not available
+        logger.info("pluggy not available, skipping plugin loading: %s", e)
+        logger.debug("pluggy not available, skipping plugin loading: %s", e)
+    except Exception as e:
+        # Error loading plugins
+        logger.error("Error loading plugins: %s", e)
+        logger.debug("Error loading plugins: %s", e)
+    
+    return {}

edsl/logger.py

@@ -0,0 +1,146 @@
+"""
+Logger module for EDSL.
+
+This module provides a centralized logging configuration for the EDSL package.
+It configures console and file logging with appropriate formatting.
+"""
+
+import logging
+import os
+import sys
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+# Create the logger
+logger = logging.getLogger("edsl")
+logger.setLevel(logging.ERROR)  # Default level
+
+# Avoid adding handlers multiple times when imported in different modules
+if not logger.handlers:
+    # Console handler removed - logs only go to file now
+
+    # File handler - create logs directory if it doesn't exist
+    try:
+        log_dir = Path.home() / ".edsl" / "logs"
+        os.makedirs(log_dir, exist_ok=True)
+
+        file_handler = RotatingFileHandler(
+            log_dir / "edsl.log", maxBytes=5 * 1024 * 1024, backupCount=3  # 5 MB
+        )
+        file_handler.setLevel(logging.ERROR)
+        file_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+    except Exception as e:
+        # Don't fail if file logging can't be set up
+        # No console handler to adjust
+        print(f"WARNING: Could not set up file logging: {e}")
+
+
+def get_logger(name):
+    """
+    Get a logger for a specific module.
+
+    Args:
+        name: Usually __name__ of the module
+
+    Returns:
+        A Logger instance configured with the EDSL settings
+    """
+    return logging.getLogger(f"edsl.{name}")
+
+
+def set_level(level):
+    """
+    Set the logging level for the EDSL logger.
+
+    Args:
+        level: A logging level (e.g., logging.DEBUG, logging.INFO, etc.)
+    """
+    logger.setLevel(level)
+    for handler in logger.handlers:
+        handler.setLevel(level)
+
+    # Update child loggers
+    for logger_name in logging.root.manager.loggerDict:
+        if logger_name.startswith("edsl."):
+            logging.getLogger(logger_name).setLevel(level)
+
+
+# Convenience function to avoid importing logging in every file
+def debug(msg, *args, **kwargs):
+    logger.debug(msg, *args, **kwargs)
+
+
+def info(msg, *args, **kwargs):
+    logger.info(msg, *args, **kwargs)
+
+
+def warning(msg, *args, **kwargs):
+    logger.warning(msg, *args, **kwargs)
+
+
+def error(msg, *args, **kwargs):
+    logger.error(msg, *args, **kwargs)
+
+
+def critical(msg, *args, **kwargs):
+    logger.critical(msg, *args, **kwargs)
+
+
+def exception(msg, *args, **kwargs):
+    """Log an exception with traceback at the ERROR level"""
+    logger.exception(msg, *args, **kwargs)
+
+
+def configure_from_config():
+    """
+    Configure logging based on EDSL_LOG_LEVEL environment variable or config.
+
+    This function looks for the EDSL_LOG_LEVEL setting in the config and sets
+    the logging level accordingly. Valid values are:
+    - DEBUG
+    - INFO
+    - WARNING
+    - ERROR
+    - CRITICAL    
+    If no configuration is found, the default level (ERROR) is maintained.
+
+    """
+    try:
+        import os
+
+        # First check environment variable
+        log_level = os.environ.get("EDSL_LOG_LEVEL")
+
+        # If not in environment, try to get from config
+        if not log_level:
+            try:
+                from edsl.config import CONFIG
+
+                log_level = CONFIG.EDSL_LOG_LEVEL
+            except (ImportError, AttributeError):
+                # Config might not be available or doesn't have EDSL_LOG_LEVEL
+                pass
+
+        if log_level:
+            # Convert to uppercase to match logging constants
+            log_level = log_level.upper()
+
+            # Map string to logging level
+            level_map = {
+                "DEBUG": logging.DEBUG,
+                "INFO": logging.INFO,
+                "WARNING": logging.WARNING,
+                "ERROR": logging.ERROR,
+                "CRITICAL": logging.CRITICAL,
+            }
+
+            if log_level in level_map:
+                set_level(level_map[log_level])
+                info(f"Log level set to {log_level} from configuration")
+            else:
+                warning(f"Invalid log level in configuration: {log_level}")
+    except Exception as e:
+        # Catch any exceptions to ensure logging configuration doesn't break the application
+        warning(f"Error configuring logging from config: {e}")

edsl/notebooks/__init__.py

@@ -1,3 +1,26 @@
+"""
+The notebooks module provides tools for working with Jupyter notebooks.
+
+It includes classes for notebook creation, manipulation, and conversion
+to other formats such as LaTeX.
+"""
+
 from .notebook import Notebook
+from .notebook_to_latex import NotebookToLaTeX
+from .exceptions import (
+    NotebookError,
+    NotebookValueError,
+    NotebookFormatError,
+    NotebookConversionError,
+    NotebookEnvironmentError,
+)
 
-__all__ = ["Notebook"]
+__all__ = [
+    "Notebook", 
+    "NotebookToLaTeX",
+    "NotebookError",
+    "NotebookValueError",
+    "NotebookFormatError", 
+    "NotebookConversionError",
+    "NotebookEnvironmentError",
+]

edsl/notebooks/exceptions.py

@@ -0,0 +1,82 @@
+"""
+Custom exceptions for the notebooks module.
+"""
+
+from ..base import BaseException
+
+
+class NotebookError(BaseException):
+    """
+    Base exception class for all notebook-related errors.
+    
+    This is the parent class for all exceptions related to notebook
+    operations, including creation, validation, and conversion.
+    """
+    relevant_doc = "https://docs.expectedparrot.com/"
+
+
+class NotebookValueError(NotebookError):
+    """
+    Exception raised when an invalid value is provided to a notebook method.
+    
+    This exception occurs when attempting to create or modify a notebook
+    with invalid values, such as:
+    - Invalid data format
+    - Incompatible notebook contents
+    
+    Examples:
+        ```python
+        # Attempting to create a notebook with invalid data
+        notebook = Notebook(data=invalid_data)  # Raises NotebookValueError
+        ```
+    """
+    relevant_doc = "https://docs.expectedparrot.com/"
+    
+
+class NotebookFormatError(NotebookError):
+    """
+    Exception raised when a notebook's format is invalid.
+    
+    This exception occurs when the notebook structure does not conform
+    to the expected Jupyter Notebook format.
+    
+    Examples:
+        ```python
+        # Attempting to load a notebook with invalid format
+        notebook = Notebook.from_dict(invalid_dict)  # Raises NotebookFormatError
+        ```
+    """
+    relevant_doc = "https://docs.expectedparrot.com/"
+
+
+class NotebookConversionError(NotebookError):
+    """
+    Exception raised when a notebook conversion fails.
+    
+    This exception occurs when attempting to convert a notebook to another
+    format (like LaTeX) and the conversion process fails.
+    
+    Examples:
+        ```python
+        # Attempting to convert a notebook to LaTeX with invalid options
+        notebook.to_latex(invalid_options)  # Raises NotebookConversionError
+        ```
+    """
+    relevant_doc = "https://docs.expectedparrot.com/"
+
+
+class NotebookEnvironmentError(NotebookError):
+    """
+    Exception raised when the notebook environment is not supportable.
+    
+    This exception occurs when attempting to create a notebook in an 
+    environment that doesn't provide required context, such as when
+    trying to create a notebook from within itself outside of VS Code.
+    
+    Examples:
+        ```python
+        # Attempting to create a notebook from within itself in an unsupported IDE
+        notebook = Notebook()  # Raises NotebookEnvironmentError
+        ```
+    """
+    relevant_doc = "https://docs.expectedparrot.com/"

edsl/notebooks/notebook.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 import json
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from rich.table import Table
 from uuid import uuid4
 
 from ..base import Base
@@ -47,7 +50,8 @@ class Notebook(Base):
             self.data = json.loads(json.dumps(data))
         else:
             # TODO: Support for IDEs other than VSCode
-            raise NotImplementedError(
+            from .exceptions import NotebookEnvironmentError
+            raise NotebookEnvironmentError(
                 "Cannot create a notebook from within itself in this development environment"
             )
 
@@ -251,7 +255,7 @@ class Notebook(Base):
 
         :param filename: Name of the output folder and main tex file (without extension)
         """
-        from .NotebookToLaTeX import NotebookToLaTeX
+        from .notebook_to_latex import NotebookToLaTeX
 
         NotebookToLaTeX(self).convert(filename)
 

edsl/notebooks/notebook_to_latex.py

@@ -2,7 +2,6 @@ from typing import Optional, Dict
 import os
 import nbformat
 from nbconvert.exporters import LatexExporter
-from nbconvert.writers import FilesWriter
 
 
 class NotebookToLaTeX:
@@ -123,7 +122,7 @@ To clean up build files:
 
 # Example usage:
 if __name__ == "__main__":
-    from edsl import Notebook
+    from .. import Notebook
 
     # Create or load a notebook
     notebook = Notebook.example()

edsl/plugins/__init__.py

@@ -0,0 +1,63 @@
+"""EDSL Plugins module for extending functionality with custom plugins."""
+
+# Import for public API
+from .plugin_host import PluginHost, get_plugin_manager
+from .exceptions import (
+    PluginException,
+    PluginNotFoundError,
+    PluginInstallationError,
+    GitHubRepoError,
+    InvalidPluginError,
+    PluginMethodError,
+    PluginDependencyError
+)
+from .cli import PluginCLI
+# Import the Typer CLI
+from .cli_typer import app as typer_app
+
+# Public API functions
+def install_from_github(github_url, branch=None):
+    """Install a plugin from a GitHub repository."""
+    return PluginHost.install_from_github(github_url, branch)
+
+def uninstall_plugin(plugin_name):
+    """Uninstall a plugin by name."""
+    return PluginHost.uninstall_plugin(plugin_name)
+
+def list_plugins():
+    """List all installed plugins."""
+    return PluginHost.list_plugins()
+
+def get_exports():
+    """Get objects exported to the global namespace by plugins."""
+    return PluginHost.get_exports()
+
+def cli():
+    """Run the plugin CLI (legacy version)."""
+    from .cli import main
+    main()
+
+def cli_typer():
+    """Run the Typer-based plugin CLI."""
+    from .cli_typer import run
+    run()
+
+__all__ = [
+    'PluginHost',
+    'get_plugin_manager',
+    'install_from_github',
+    'uninstall_plugin',
+    'list_plugins',
+    'get_exports',
+    'cli',
+    'cli_typer',
+    'PluginCLI',
+    'typer_app',
+    'PluginException',
+    'PluginNotFoundError',
+    'PluginInstallationError',
+    'GitHubRepoError',
+    'InvalidPluginError',
+    'PluginMethodError',
+    'PluginDependencyError'
+]

edsl/plugins/built_in/export_example.py

@@ -0,0 +1,50 @@
+# Example plugin that demonstrates exporting objects to the global namespace
+import pluggy
+from typing import Dict, Any, Optional
+
+# Define a hook implementation marker
+hookimpl = pluggy.HookimplMarker("edsl")
+
+# Create a class that will be exported to the global namespace
+class ExportedClass:
+    """An example class exported from a plugin to the global namespace."""
+    
+    def __init__(self, name="Example"):
+        self.name = name
+        
+    def greet(self):
+        """Return a greeting message."""
+        return f"Hello from {self.name}!"
+    
+# A function to be exported to the global namespace
+def exported_function(text):
+    """An example function exported from a plugin to the global namespace."""
+    return f"Processed: {text}"
+
+class ExportExample:
+    """Example plugin that exports objects to the global namespace."""
+    
+    @hookimpl
+    def plugin_name(self):
+        return "ExportExample"
+    
+    @hookimpl
+    def plugin_description(self):
+        return "Demonstrates how to export objects to the global namespace."
+    
+    @hookimpl
+    def edsl_plugin(self, plugin_name=None):
+        if plugin_name is None or plugin_name == "ExportExample":
+            return self
+    
+    @hookimpl
+    def get_plugin_methods(self):
+        return {}
+    
+    @hookimpl
+    def exports_to_namespace(self) -> Dict[str, Any]:
+        """Export objects to the global namespace."""
+        return {
+            "ExportedClass": ExportedClass,
+            "exported_function": exported_function
+        }

edsl/plugins/built_in/pig_latin.py

@@ -0,0 +1,67 @@
+# edsl/plugins/text_plugins.py
+import pluggy
+from typing import Dict, Any, Optional
+
+# Define a hook implementation marker
+hookimpl = pluggy.HookimplMarker("edsl")
+
+# Create an exportable class for demonstration
+class PigLatinTranslator:
+    """A class that translates text to Pig Latin."""
+    
+    @staticmethod
+    def translate(text):
+        """Translate text to Pig Latin."""
+        words = text.split()
+        result = []
+        for word in words:
+            # Simple Pig Latin rule: move first letter to end and add "ay"
+            if len(word) > 1:
+                pig_latin = word[1:] + word[0] + "ay"
+                result.append(pig_latin)
+            else:
+                result.append(word + "ay")
+        return " ".join(result)
+
+class PigLatin:
+    """Text processing plugin."""
+    
+    @hookimpl
+    def plugin_name(self):
+        return "PigLatin"
+    
+    @hookimpl
+    def plugin_description(self):
+        return "This plugin translates text to Pig Latin."
+        
+    @hookimpl
+    def edsl_plugin(self, plugin_name=None):
+        if plugin_name is None or plugin_name == "PigLatin":
+            return self
+    
+    @hookimpl
+    def get_plugin_methods(self):
+        return {
+            "pig_latin": self.pig_latin
+        }
+    
+    @hookimpl
+    def exports_to_namespace(self) -> Dict[str, Any]:
+        """Export objects to the global namespace."""
+        return {
+            "PigLatinTranslator": PigLatinTranslator
+        }
+    
+    def pig_latin(self, survey, *args, **kwargs):
+        """Get pig latin translation of survey questions."""
+        # A simple Pig Latin translator without using the model
+        # This avoids needing API keys for testing
+        
+        #print(f"Processing survey: {survey}")
+        
+        # Translate each question text
+        translations = []
+        for question in survey.questions:
+            translations.append(PigLatinTranslator.translate(question.question_text))
+            
+        return translations