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

edsl/questions/register_questions_meta.py

@@ -62,7 +62,8 @@ class RegisterQuestionsMeta(ABCMeta):
             if hasattr(cls, "question_type"):
                 d[cls.question_type] = cls
             else:
-                raise Exception(
+                from .exceptions import QuestionMissingTypeError
+                raise QuestionMissingTypeError(
                     f"Class {classname} does not have a question_type class attribute"
                 )
         return d

edsl/questions/response_validator_abc.py

@@ -77,8 +77,12 @@ class ResponseValidatorABC(ABC):
         ConstrainedNumericResponse(answer=42, comment=None, generated_tokens=None)
         """
         try:
-            return self.response_model(**data)
-        except ValidationError as e:
+            # Use model_validate instead of direct instantiation
+            return self.response_model.model_validate(data)
+        except (ValidationError, QuestionAnswerValidationError) as e:
+            # Pass through QuestionAnswerValidationError or convert ValidationError
+            if isinstance(e, QuestionAnswerValidationError):
+                raise
             raise QuestionAnswerValidationError(
                 message=str(e), pydantic_error=e, data=data, model=self.response_model
             )

edsl/questions/response_validator_factory.py

@@ -1,5 +1,6 @@
-from edsl.questions.data_structures import BaseModel
-from edsl.questions.response_validator_abc import ResponseValidatorABC
+from typing import Type, List
+from .data_structures import BaseModel
+from .response_validator_abc import ResponseValidatorABC
 
 
 class ResponseValidatorFactory:
@@ -9,7 +10,7 @@ class ResponseValidatorFactory:
         self.question = question
 
     @property
-    def response_model(self) -> type["BaseModel"]:
+    def response_model(self) -> Type["BaseModel"]:
         if self.question._response_model is not None:
             return self.question._response_model
         else:
@@ -18,17 +19,14 @@ class ResponseValidatorFactory:
     @property
     def response_validator(self) -> "ResponseValidatorABC":
         """Return the response validator."""
-        params = (
-            {
-                "response_model": self.question.response_model,
-            }
-            | {k: getattr(self.question, k) for k in self.validator_parameters}
-            | {"exception_to_throw": getattr(self.question, "exception_to_throw", None)}
-            | {"override_answer": getattr(self.question, "override_answer", None)}
-        )
+        params = {}
+        params.update({"response_model": self.question.response_model})
+        params.update({k: getattr(self.question, k) for k in self.validator_parameters})
+        params.update({"exception_to_throw": getattr(self.question, "exception_to_throw", None)})
+        params.update({"override_answer": getattr(self.question, "override_answer", None)})
         return self.question.response_validator_class(**params)
 
     @property
-    def validator_parameters(self) -> list[str]:
+    def validator_parameters(self) -> List[str]:
         """Return the parameters required for the response validator."""
         return self.question.response_validator_class.required_params

edsl/results/report.py

@@ -173,7 +173,7 @@ class Report:
 
 if __name__ == "__main__":
     # Suppose you have an existing Dataset
-    from edsl import Results
+    from .. import Results
     ds = Results.example().select("how_feeling", "how_feeling_yesterday")
 
     # Provide a custom template string

edsl/results/result.py

@@ -259,14 +259,16 @@ class Result(Base, UserDict):
     def check_expression(self, expression: str) -> None:
         for key in self.problem_keys:
             if key in expression and key + "." not in expression:
-                raise ValueError(
-                    f"Key by iself {key} is problematic. Use the full key {key + '.' + key} name instead."
+                from .exceptions import ResultsColumnNotFoundError
+                raise ResultsColumnNotFoundError(
+                    f"Key by itself {key} is problematic. Use the full key {key + '.' + key} name instead."
                 )
         return None
 
     def code(self):
         """Return a string of code that can be used to recreate the Result object."""
-        raise NotImplementedError
+        from .exceptions import ResultsError
+        raise ResultsError("The code() method is not implemented for Result objects")
 
     @property
     def problem_keys(self) -> list[str]:
@@ -567,7 +569,8 @@ class Result(Base, UserDict):
             elif v.default is not v.empty:
                 params[k] = v.default
             else:
-                raise ValueError(f"Parameter {k} not found in Result object")
+                from .exceptions import ResultsError
+                raise ResultsError(f"Parameter {k} not found in Result object")
         return scoring_function(**params)
 
     @classmethod