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

edsl/questions/QuestionBudget.py

@@ -5,7 +5,7 @@ from pydantic import Field, BaseModel, validator
 
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import IntegerDescriptor, QuestionOptionsDescriptor
-from edsl.questions.response_validator_abc import ResponseValidatorABC
+from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
 
 
 class BudgewResponseValidator(ResponseValidatorABC):

edsl/questions/QuestionCheckBox.py

@@ -13,10 +13,10 @@ from edsl.questions.descriptors import (
 from edsl.questions.decorators import inject_exception
 
 from pydantic import field_validator
-from edsl.questions.response_validator_abc import ResponseValidatorABC
-from edsl.questions.data_structures import BaseResponse
+from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
+from edsl.questions.ResponseValidatorABC import BaseResponse
 
-from edsl.exceptions.questions import QuestionAnswerValidationError
+from edsl.exceptions import QuestionAnswerValidationError
 
 from pydantic import BaseModel, Field, conlist
 from typing import List, Literal, Optional, Annotated

edsl/questions/QuestionExtract.py

@@ -6,8 +6,9 @@ from typing import Any, Optional, Dict
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import AnswerTemplateDescriptor
 
-from edsl.questions.response_validator_abc import ResponseValidatorABC
-from edsl.questions.data_structures import BaseResponse
+from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
+from edsl.questions.ResponseValidatorABC import BaseResponse
+from edsl.exceptions import QuestionAnswerValidationError
 from edsl.questions.decorators import inject_exception
 
 from typing import Dict, Any
@@ -56,7 +57,7 @@ def dict_to_pydantic_model(input_dict: Dict[str, Any]) -> Any:
     DynamicModel = create_model("DynamicModel", **field_definitions)
 
     class AnswerModel(BaseResponse):
-        answer: "DynamicModel"
+        answer: DynamicModel
         generated_tokens: Optional[str] = None
         comment: Optional[str] = None
 
@@ -112,8 +113,6 @@ class QuestionExtract(QuestionBase):
         :param question_name: The name of the question.
         :param question_text: The text of the question.
         :param answer_template: The template for the answer.
-        :param answering_instructions: Instructions for answering the question.
-        :param question_presentation: The presentation of the question.
         """
         self.question_name = question_name
         self.question_text = question_text
@@ -143,6 +142,9 @@ class QuestionExtract(QuestionBase):
         )
         return question_html_content
 
+    ################
+    # Helpful methods
+    ################
     @classmethod
     @inject_exception
     def example(cls) -> QuestionExtract:

edsl/questions/QuestionFreeText.py

@@ -5,14 +5,15 @@ from uuid import uuid4
 from pydantic import field_validator
 
 from edsl.questions.QuestionBase import QuestionBase
-from edsl.questions.response_validator_abc import ResponseValidatorABC
+from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
 
-from edsl.exceptions.questions import QuestionAnswerValidationError
+from edsl.exceptions import QuestionAnswerValidationError
 from edsl.questions.decorators import inject_exception
 
 from pydantic import BaseModel
 from typing import Optional, Any, List
 
+from edsl.exceptions import QuestionAnswerValidationError
 from edsl.prompts.Prompt import Prompt
 
 

edsl/questions/QuestionList.py

@@ -1,18 +1,23 @@
 from __future__ import annotations
-import json
+import random
+import textwrap
 from typing import Any, Optional, Union
-
-from pydantic import Field
-from json_repair import repair_json
-
-from edsl.exceptions.questions import QuestionAnswerValidationError
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import IntegerOrNoneDescriptor
 from edsl.questions.decorators import inject_exception
-from edsl.questions.response_validator_abc import ResponseValidatorABC
 
+from pydantic import field_validator, Field
+from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
+from edsl.questions.ResponseValidatorABC import BaseResponse
+
+from edsl.exceptions import QuestionAnswerValidationError
+import textwrap
+import json
 
-def convert_string(s: str) -> Union[float, int, str, dict]:
+from json_repair import repair_json
+
+
+def convert_string(s):
     """Convert a string to a more appropriate type if possible.
 
     >>> convert_string("3.14")
@@ -55,7 +60,7 @@ def convert_string(s: str) -> Union[float, int, str, dict]:
     return s
 
 
-def create_model(max_list_items: int, permissive: bool) -> "ListResponse":
+def create_model(max_list_items: int, permissive):
     from pydantic import BaseModel
 
     if permissive or max_list_items is None:
@@ -130,8 +135,8 @@ class QuestionList(QuestionBase):
         self,
         question_name: str,
         question_text: str,
-        include_comment: bool = True,
         max_list_items: Optional[int] = None,
+        include_comment: bool = True,
         answering_instructions: Optional[str] = None,
         question_presentation: Optional[str] = None,
         permissive: bool = False,
@@ -181,6 +186,9 @@ class QuestionList(QuestionBase):
         ).render(question_name=self.question_name)
         return question_html_content
 
+    ################
+    # Helpful methods
+    ################
     @classmethod
     @inject_exception
     def example(

edsl/questions/QuestionMultipleChoice.py

@@ -8,7 +8,7 @@ from edsl.scenarios.Scenario import Scenario
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import QuestionOptionsDescriptor
 from edsl.questions.decorators import inject_exception
-from edsl.questions.response_validator_abc import ResponseValidatorABC
+from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
 
 
 def create_response_model(choices: List[str], permissive: bool = False):
@@ -120,9 +120,9 @@ class QuestionMultipleChoice(QuestionBase):
 
     question_type = "multiple_choice"
     purpose = "When options are known and limited"
-    question_options: Union[list[str], list[list], list[float], list[int]] = (
-        QuestionOptionsDescriptor()
-    )
+    question_options: Union[
+        list[str], list[list], list[float], list[int]
+    ] = QuestionOptionsDescriptor()
     _response_model = None
     response_validator_class = MultipleChoiceResponseValidator
 
@@ -175,54 +175,8 @@ class QuestionMultipleChoice(QuestionBase):
         else:
             return create_response_model(self.question_options, self.permissive)
 
-    @staticmethod
-    def _translate_question_options(
-        question_options, substitution_dict: dict
-    ) -> list[str]:
-
-        if isinstance(question_options, str):
-            # If dynamic options are provided like {{ options }}, render them with the scenario
-            # We can check if it's in the Scenario.
-            from jinja2 import Environment, meta
-
-            env = Environment()
-            parsed_content = env.parse(question_options)
-            template_variables = list(meta.find_undeclared_variables(parsed_content))
-            # print("The template variables are: ", template_variables)
-            question_option_key = template_variables[0]
-            # We need to deal with possibility it's actually an answer to a question.
-            potential_replacement = substitution_dict.get(question_option_key, None)
-
-            if isinstance(potential_replacement, list):
-                # translated_options = potential_replacement
-                return potential_replacement
-
-            if isinstance(potential_replacement, QuestionBase):
-                if hasattr(potential_replacement, "answer") and isinstance(
-                    potential_replacement.answer, list
-                ):
-                    return potential_replacement.answer
-                    # translated_options = potential_replacement.answer
-
-            # if not isinstance(potential_replacement, list):
-            # translated_options = potential_replacement
-
-            if potential_replacement is None:
-                # Nope - maybe it's in the substition dict?
-                raise ValueError(
-                    f"Could not find the key '{question_option_key}' in the scenario."
-                    f"The substition dict was: '{substitution_dict}.'"
-                    f"The question options were: '{question_options}'."
-                )
-        else:
-            translated_options = [
-                Template(str(option)).render(substitution_dict)
-                for option in question_options
-            ]
-        return translated_options
-
     def _translate_answer_code_to_answer(
-        self, answer_code: int, replacements_dict: Optional[dict] = None
+        self, answer_code: int, scenario: Optional["Scenario"] = None
     ):
         """Translate the answer code to the actual answer.
 
@@ -238,24 +192,26 @@ class QuestionMultipleChoice(QuestionBase):
         'Happy'
 
         """
-        if replacements_dict is None:
-            replacements_dict = {}
-        translated_options = self._translate_question_options(
-            self.question_options, replacements_dict
-        )
 
+        scenario = scenario or Scenario()
+
+        if isinstance(self.question_options, str):
+            # If dynamic options are provided like {{ options }}, render them with the scenario
+            from jinja2 import Environment, meta
+
+            env = Environment()
+            parsed_content = env.parse(self.question_options)
+            question_option_key = list(meta.find_undeclared_variables(parsed_content))[
+                0
+            ]
+            translated_options = scenario.get(question_option_key)
+        else:
+            translated_options = [
+                Template(str(option)).render(scenario)
+                for option in self.question_options
+            ]
         if self._use_code:
-            try:
-                return translated_options[int(answer_code)]
-            except IndexError:
-                raise ValueError(
-                    f"Answer code is out of range. The answer code index was: {int(answer_code)}. The options were: {translated_options}."
-                )
-            except TypeError:
-                raise ValueError(
-                    f"The answer code was: '{answer_code}.'",
-                    f"The options were: '{translated_options}'.",
-                )
+            return translated_options[int(answer_code)]
         else:
             # return translated_options[answer_code]
             return answer_code

edsl/questions/QuestionNumerical.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
+# from decimal import Decimal
 from random import uniform
 from typing import Any, Optional, Union, Literal
 
 from pydantic import BaseModel, Field, field_validator
 
-from edsl.exceptions.questions import QuestionAnswerValidationError
+from edsl.exceptions import QuestionAnswerValidationError
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import NumericalOrNoneDescriptor
 from edsl.questions.decorators import inject_exception
-from edsl.questions.response_validator_abc import ResponseValidatorABC
+from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
+from edsl.exceptions.questions import QuestionAnswerValidationError
 
 
 def create_numeric_response(

edsl/questions/QuestionRank.py

@@ -1,14 +1,25 @@
 from __future__ import annotations
-from typing import Optional, Any, List, Annotated, Literal
-
-from pydantic import BaseModel, Field
-
+import random
+import textwrap
+from jinja2 import Template
+from typing import Any, Optional, Union
 from edsl.questions.QuestionBase import QuestionBase
+from edsl.exceptions import QuestionAnswerValidationError
+
 from edsl.questions.descriptors import (
     QuestionOptionsDescriptor,
     NumSelectionsDescriptor,
 )
-from edsl.questions.response_validator_abc import ResponseValidatorABC
+
+from edsl.prompts import Prompt
+
+from pydantic import field_validator
+from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
+from edsl.questions.ResponseValidatorABC import BaseResponse
+from edsl.exceptions import QuestionAnswerValidationError
+
+from pydantic import BaseModel, Field, create_model
+from typing import Optional, Any, List, Annotated, Literal
 
 
 def create_response_model(
@@ -190,8 +201,7 @@ class QuestionRank(QuestionBase):
         self, answer_codes, scenario: Scenario = None
     ) -> list[str]:
         """Translate the answer code to the actual answer."""
-        from edsl.scenarios.Scenario import Scenario
-        from jinja2 import Template
+        from edsl.scenarios import Scenario
 
         scenario = scenario or Scenario()
         translated_options = [

edsl/questions/{response_validator_abc.py → ResponseValidatorABC.py}

@@ -1,22 +1,23 @@
 from abc import ABC, abstractmethod
+from pydantic import BaseModel, Field, field_validator
+
+# from decimal import Decimal
 from typing import Optional, Any, List, TypedDict
 
-from pydantic import BaseModel, Field, field_validator, ValidationError
+from edsl.exceptions import QuestionAnswerValidationError
+from pydantic import ValidationError
 
-from edsl.exceptions.questions import QuestionAnswerValidationError
-from edsl.questions.ExceptionExplainer import ExceptionExplainer
 
-from edsl.questions.data_structures import (
-    RawEdslAnswerDict,
-    EdslAnswerDict,
-)
+class BaseResponse(BaseModel):
+    answer: Any
+    comment: Optional[str] = None
+    generated_tokens: Optional[str] = None
 
 
 class ResponseValidatorABC(ABC):
     required_params: List[str] = []
 
     def __init_subclass__(cls, **kwargs):
-        """This is a metaclass that ensures that all subclasses of ResponseValidatorABC have the required class variables."""
         super().__init_subclass__(**kwargs)
         required_class_vars = ["required_params", "valid_examples", "invalid_examples"]
         for var in required_class_vars:
@@ -51,7 +52,12 @@ class ResponseValidatorABC(ABC):
         if not hasattr(self, "permissive"):
             self.permissive = False
 
-        self.fixes_tried = 0  # how many times we've tried to fix the answer
+        self.fixes_tried = 0
+
+    class RawEdslAnswerDict(TypedDict):
+        answer: Any
+        comment: Optional[str]
+        generated_tokens: Optional[str]
 
     def _preprocess(self, data: RawEdslAnswerDict) -> RawEdslAnswerDict:
         """This is for testing purposes. A question can be given an exception to throw or an answer to always return.
@@ -66,8 +72,7 @@ class ResponseValidatorABC(ABC):
         return self.override_answer if self.override_answer else data
 
     def _base_validate(self, data: RawEdslAnswerDict) -> BaseModel:
-        """This is the main validation function. It takes the response_model and checks the data against it,
-        returning the instantiated model.
+        """This is the main validation function. It takes the response_model and checks the data against it, returning the instantiated model.
 
         >>> rv = ResponseValidatorABC.example("numerical")
         >>> rv._base_validate({"answer": 42})
@@ -76,13 +81,16 @@ class ResponseValidatorABC(ABC):
         try:
             return self.response_model(**data)
         except ValidationError as e:
-            raise QuestionAnswerValidationError(
-                message=str(e), pydantic_error=e, data=data, model=self.response_model
-            )
+            raise QuestionAnswerValidationError(e, data=data, model=self.response_model)
 
     def post_validation_answer_convert(self, data):
         return data
 
+    class EdslAnswerDict(TypedDict):
+        answer: Any
+        comment: Optional[str]
+        generated_tokens: Optional[str]
+
     def validate(
         self,
         raw_edsl_answer_dict: RawEdslAnswerDict,
@@ -120,12 +128,10 @@ class ResponseValidatorABC(ABC):
             edsl_answer_dict = self._extract_answer(pydantic_edsl_answer)
             return self._post_process(edsl_answer_dict)
         except QuestionAnswerValidationError as e:
+            if verbose:
+                print(f"Failed to validate {raw_edsl_answer_dict}; {str(e)}")
             return self._handle_exception(e, raw_edsl_answer_dict)
 
-    def human_explanation(self, e: QuestionAnswerValidationError):
-        explanation = ExceptionExplainer(e, model_response=e.data).explain()
-        return explanation
-
     def _handle_exception(self, e: Exception, raw_edsl_answer_dict) -> EdslAnswerDict:
         if self.fixes_tried == 0:
             self.original_exception = e
@@ -134,18 +140,12 @@ class ResponseValidatorABC(ABC):
             self.fixes_tried += 1
             fixed_data = self.fix(raw_edsl_answer_dict)
             try:
-                return self.validate(fixed_data, fix=True)  # early return if validates
+                return self.validate(fixed_data, fix=True)
             except Exception as e:
                 pass  # we don't log failed fixes
 
-        # If the exception is already a QuestionAnswerValidationError, raise it
-        if isinstance(self.original_exception, QuestionAnswerValidationError):
-            raise self.original_exception
-
-        # If nothing worked, raise the original exception
         raise QuestionAnswerValidationError(
-            message=self.original_exception,
-            pydantic_error=self.original_exception,
+            self.original_exception,
             data=raw_edsl_answer_dict,
             model=self.response_model,
         )
@@ -167,22 +167,8 @@ class ResponseValidatorABC(ABC):
         return q.response_validator
 
 
-def main():
-    rv = ResponseValidatorABC.example()
-    print(rv.validate({"answer": 42}))
-
-
 # Example usage
 if __name__ == "__main__":
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)
-
-    rv = ResponseValidatorABC.example()
-    # print(rv.validate({"answer": 42}))
-
-    rv = ResponseValidatorABC.example()
-    try:
-        rv.validate({"answer": "120"})
-    except QuestionAnswerValidationError as e:
-        print(rv.human_explanation(e))

edsl/questions/SimpleAskMixin.py

@@ -1,3 +1,5 @@
+from rich.table import Table
+from rich.console import Console
 import math
 
 
@@ -8,9 +10,6 @@ def logprob_to_prob(logprob):
 
 
 def format_output(data):
-    from rich.table import Table
-    from rich.console import Console
-
     content = data["choices"][0]["logprobs"]["content"]
     table = Table(show_header=True, header_style="bold magenta")
 
@@ -66,7 +65,7 @@ class SimpleAskMixin:
         system_prompt="You are a helpful agent pretending to be a human. Do not break character",
         top_logprobs=4,
     ):
-        from edsl.language_models.model import Model
+        from edsl import Model
 
         if model is None:
             model = Model()

edsl/questions/__init__.py

@@ -1,6 +1,6 @@
 # Schemas
 from edsl.questions.settings import Settings
-from edsl.questions.register_questions_meta import RegisterQuestionsMeta
+from edsl.questions.RegisterQuestionsMeta import RegisterQuestionsMeta
 
 # Base Class
 from edsl.questions.QuestionBase import QuestionBase
@@ -11,7 +11,6 @@ from edsl.questions.QuestionExtract import QuestionExtract
 from edsl.questions.QuestionFreeText import QuestionFreeText
 from edsl.questions.QuestionFunctional import QuestionFunctional
 from edsl.questions.QuestionList import QuestionList
-from edsl.questions.QuestionMatrix import QuestionMatrix
 from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
 from edsl.questions.QuestionNumerical import QuestionNumerical
 from edsl.questions.QuestionBudget import QuestionBudget

edsl/questions/derived/QuestionLinearScale.py

@@ -40,12 +40,9 @@ class QuestionLinearScale(QuestionMultipleChoice):
             include_comment=include_comment,
         )
         self.question_options = question_options
-        if isinstance(option_labels, str):
-            self.option_labels = option_labels
-        else:
-            self.option_labels = (
-                {int(k): v for k, v in option_labels.items()} if option_labels else {}
-            )
+        self.option_labels = (
+            {int(k): v for k, v in option_labels.items()} if option_labels else {}
+        )
         self.answering_instructions = answering_instructions
         self.question_presentation = question_presentation
 

edsl/questions/derived/QuestionTopK.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from typing import Optional
 
-from edsl.exceptions.questions import QuestionCreationValidationError
+from edsl.exceptions import QuestionCreationValidationError
 from edsl.questions.QuestionCheckBox import QuestionCheckBox
 from edsl.questions.decorators import inject_exception
 

edsl/questions/descriptors.py

@@ -3,7 +3,7 @@
 from abc import ABC, abstractmethod
 import re
 from typing import Any, Callable, List, Optional
-from edsl.exceptions.questions import (
+from edsl.exceptions import (
     QuestionCreationValidationError,
     QuestionAnswerValidationError,
 )
@@ -181,25 +181,11 @@ class NumSelectionsDescriptor(BaseDescriptor):
 
 
 class OptionLabelDescriptor(BaseDescriptor):
-    """Validate that the `option_label` attribute is a string.
-
-    >>> class TestQuestion:
-    ...     option_label = OptionLabelDescriptor()
-    ...     def __init__(self, option_label: str):
-    ...         self.option_label = option_label
-
-    >>> _ = TestQuestion("{{Option}}")
-
-    """
+    """Validate that the `option_label` attribute is a string."""
 
     def validate(self, value, instance):
         """Validate the value is a string."""
-        if isinstance(value, str):
-            if "{{" in value and "}}" in value:
-                # they're trying to use a dynamic question name - let's let this play out
-                return None
-
-        key_values = [int(v) for v in value.keys()]
+        # key_values = [int(v) for v in value.keys()]
 
         if value and (key_values := [float(v) for v in value.keys()]) != []:
             if min(key_values) != min(instance.question_options):

edsl/questions/question_registry.py

@@ -96,7 +96,7 @@ class Question(metaclass=Meta):
 
         >>> from edsl import Question
         >>> Question.list_question_types()
-        ['checkbox', 'extract', 'free_text', 'functional', 'likert_five', 'linear_scale', 'list', 'matrix', 'multiple_choice', 'numerical', 'rank', 'top_k', 'yes_no']
+        ['checkbox', 'extract', 'free_text', 'functional', 'likert_five', 'linear_scale', 'list', 'multiple_choice', 'numerical', 'rank', 'top_k', 'yes_no']
         """
         return [
             q

edsl/results/CSSParameterizer.py

@@ -67,7 +67,7 @@ class CSSParameterizer:
         missing_vars = self._validate_parameters(parameters)
 
         if missing_vars:
-            # print(f"Error: Missing required variables: {missing_vars}")
+            print(f"Error: Missing required variables: {missing_vars}")
             return None
 
         # Format parameters with -- prefix if not present