edsl 0.1.50__py3-none-any.whl → 0.1.52__py3-none-any.whl

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

@@ -122,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/prompts/__init__.py

@@ -1,4 +1,25 @@
-# from edsl.prompts.registry import get_classes
+"""
+The prompts module provides tools for creating and managing prompts.
+
+It includes classes for template-based prompts with variable substitution,
+prompt rendering, and component management for language model interactions.
+"""
 from .prompt import Prompt
+from .exceptions import (
+    PromptError,
+    TemplateRenderError,
+    PromptBadQuestionTypeError,
+    PromptBadLanguageModelTypeError,
+    PromptValueError,
+    PromptImplementationError
+)
 
-__all__ = ["Prompt"]
+__all__ = [
+    "Prompt",
+    "PromptError", 
+    "TemplateRenderError",
+    "PromptBadQuestionTypeError", 
+    "PromptBadLanguageModelTypeError",
+    "PromptValueError",
+    "PromptImplementationError"
+]

edsl/prompts/prompt.py

@@ -145,7 +145,7 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         if path_to_folder is None:
             from importlib import resources
 
-            path_to_folder = resources.path("edsl.questions", "prompt_templates")
+            path_to_folder = resources.path("..questions", "prompt_templates")
 
         try:
             folder_path = Path(path_to_folder)

edsl/questions/__init__.py

@@ -120,10 +120,10 @@ from .question_budget import QuestionBudget
 from .question_rank import QuestionRank
 
 # Questions derived from core questions
-from .derived.question_likert_five import QuestionLikertFive
-from .derived.question_linear_scale import QuestionLinearScale
-from .derived.question_yes_no import QuestionYesNo
-from .derived.question_top_k import QuestionTopK
+from .question_likert_five import QuestionLikertFive
+from .question_linear_scale import QuestionLinearScale
+from .question_yes_no import QuestionYesNo
+from .question_top_k import QuestionTopK
 
 from .exceptions import QuestionScenarioRenderError
 

edsl/questions/answer_validator_mixin.py

@@ -1,10 +1,5 @@
 """Mixin with validators for LLM answers to questions."""
 
-import re
-from typing import Any, Type, Union
-from .exceptions import (
-    QuestionAnswerValidationError,
-)
 
 
 class AnswerValidatorMixin:

edsl/questions/compose_questions.py

@@ -3,6 +3,7 @@
 from .question_functional import QuestionFunctional
 from .question_base import QuestionBase
 from ..scenarios import Scenario
+from .exceptions import QuestionValueError
 
 
 def compose_questions(
@@ -19,7 +20,6 @@ def compose_questions(
     if question_name is None:
         question_name = f"{q1.question_name}_{q2.question_name}"
     if q1.question_name not in q2.question_text:
-        from .exceptions import QuestionValueError
         raise QuestionValueError(
             f"q2 requires a field not present in q1's answer. "
             f"q1: {q1.question_name}, q2: {q2.question_name}"
@@ -30,7 +30,7 @@ def compose_questions(
     ) -> QuestionFunctional:
         """Return the answer to the second question given the answer to the first question."""
         # get the answer to the first question
-        from edsl.agents.Agent import Agent
+        from ..agents.agent import Agent
 
         first_answer = (
             q1.by(scenario)

edsl/questions/descriptors.py

@@ -230,7 +230,7 @@ class QuestionNameDescriptor(BaseDescriptor):
 
     def validate(self, value, instance):
         """Validate the value is a valid variable name."""
-        from edsl.utilities.utilities import is_valid_variable_name
+        from ..utilities.utilities import is_valid_variable_name
 
         if "{{" in value and "}}" in value:
             # they're trying to use a dynamic question name - let's let this play out

edsl/questions/question_base.py

@@ -271,8 +271,25 @@ class QuestionBase(
         """
         if not hasattr(self, "_fake_data_factory"):
             from polyfactory.factories.pydantic_factory import ModelFactory
-
-            class FakeData(ModelFactory[self.response_model]): ...
+            from random import randint, uniform
+
+            class FakeData(ModelFactory[self.response_model]):
+                # Add customization for specific question types
+                if hasattr(self, 'question_type') and self.question_type == 'numerical':
+                    @classmethod
+                    def build_answer(cls):
+                        min_val = getattr(self, 'min_value', None)
+                        max_val = getattr(self, 'max_value', None)
+                        
+                        # Default values if none provided
+                        min_val = 0 if min_val is None else min_val
+                        max_val = 100 if max_val is None else max_val
+                        
+                        # Ensure values are within bounds
+                        if isinstance(min_val, int) and isinstance(max_val, int):
+                            return randint(min_val, max_val)
+                        else:
+                            return uniform(min_val, max_val)
 
             self._fake_data_factory = FakeData
         return self._fake_data_factory
@@ -358,7 +375,19 @@ class QuestionBase(
             >>> Q.example()._validate_answer({'answer': 'Hello', 'generated_tokens': 'Hello'})
             {'answer': 'Hello', 'generated_tokens': 'Hello'}
         """
-        return self.response_validator.validate(answer, replacement_dict)
+        try:
+            return self.response_validator.validate(answer, replacement_dict)
+        except Exception as e:
+            # Ensure all validation errors are raised as QuestionAnswerValidationError
+            from .exceptions import QuestionAnswerValidationError
+            if not isinstance(e, QuestionAnswerValidationError):
+                raise QuestionAnswerValidationError(
+                    message=f"Invalid response: {e}",
+                    data=answer,
+                    model=getattr(self, 'response_model', None),
+                    pydantic_error=e if hasattr(e, 'errors') else None
+                ) from e
+            raise
 
     @property
     def name(self) -> str:

edsl/questions/question_base_prompts_mixin.py

@@ -74,7 +74,7 @@ class QuestionBasePromptsMixin:
         >>> q.get_instructions(model = "gpt3")
         Prompt(text=\"""{{question_text}}. Answer in valid JSON like so {'answer': 'comment: <>}\""")
         """
-        from edsl.language_models.model import Model
+        from ..language_models.model import Model
 
         if not hasattr(self, "_model_instructions"):
             self._model_instructions = {}
@@ -125,7 +125,7 @@ class QuestionBasePromptsMixin:
         template_text = template_manager.get_template(
             cls.question_type, "answering_instructions.jinja"
         )
-        from edsl.prompts import Prompt
+        from ..prompts import Prompt
 
         return Prompt(text=template_text)
 
@@ -134,7 +134,7 @@ class QuestionBasePromptsMixin:
         template_text = template_manager.get_template(
             cls.question_type, "question_presentation.jinja"
         )
-        from edsl.prompts import Prompt
+        from ..prompts import Prompt
 
         return Prompt(text=template_text)
 
@@ -190,7 +190,7 @@ class QuestionBasePromptsMixin:
     @property
     def new_default_instructions(self) -> "Prompt":
         "This is set up as a property because there are mutable question values that determine how it is rendered."
-        from edsl.prompts import Prompt
+        from ..prompts import Prompt
 
         return Prompt(self.question_presentation) + Prompt(self.answering_instructions)