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

edsl/questions/question_budget.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Any, Optional, Union, List
+from typing import Optional, List
 
 from pydantic import Field, BaseModel, validator
 
@@ -40,14 +40,18 @@ def create_budget_model(
         @validator("answer")
         def validate_answer(cls, v):
             if len(v) != len(question_options):
-                raise ValueError(f"Must provide {len(question_options)} values")
+                from .exceptions import QuestionAnswerValidationError
+                raise QuestionAnswerValidationError(f"Must provide {len(question_options)} values")
             if any(x < 0 for x in v):
-                raise ValueError("All values must be non-negative")
+                from .exceptions import QuestionAnswerValidationError
+                raise QuestionAnswerValidationError("All values must be non-negative")
             total = sum(v)
             if not permissive and total != budget_sum:
-                raise ValueError(f"Sum of numbers must equal {budget_sum}")
+                from .exceptions import QuestionAnswerValidationError
+                raise QuestionAnswerValidationError(f"Sum of numbers must equal {budget_sum}")
             elif permissive and total > budget_sum:
-                raise ValueError(f"Sum of numbers cannot exceed {budget_sum}")
+                from .exceptions import QuestionAnswerValidationError
+                raise QuestionAnswerValidationError(f"Sum of numbers cannot exceed {budget_sum}")
             return v
 
         class Config:

edsl/questions/question_check_box.py

@@ -1,11 +1,9 @@
 from __future__ import annotations
-import random
-from typing import Any, Optional, Union, TYPE_CHECKING
+from typing import Any, Optional, TYPE_CHECKING
 
 from jinja2 import Template
-from pydantic import field_validator
-from pydantic import BaseModel, Field, conlist
-from typing import List, Literal, Optional, Annotated
+from pydantic import BaseModel, Field
+from typing import List, Literal, Annotated
 
 from .exceptions import QuestionAnswerValidationError
 from ..scenarios import Scenario

edsl/questions/question_dict.py

@@ -1,6 +1,18 @@
+"""
+question_dict.py
+
+Drop-in replacement for `QuestionDict`, with dynamic creation of a Pydantic model 
+to validate user responses automatically (just like QuestionNumerical).
+
+
+Failure: 
+
+```python { "first_name": "Kris", "last_name": "Rosemann", "phone": "(262) 506-6064", "email": "InvestorRelations@generac.com", "title": "Senior Manager Corporate Development & Investor Relations", "external": False } ``` The first name and last name are extracted directly from the text. The phone number and email are provided in the text. The title is also given in the text. The email domain "generac.com" suggests that it is an internal email address, so "external" is set to False.
+"""
+
 from __future__ import annotations
 from typing import Union, Optional, Dict, List, Any, Type
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, create_model, ValidationError
 from jinja2 import Environment, FileSystemLoader, TemplateNotFound
 from pathlib import Path
 
@@ -16,7 +28,77 @@ from .exceptions import QuestionCreationValidationError
 from .decorators import inject_exception
 
 
+def _parse_type_string(type_str: str) -> Any:
+    """
+    Very simplistic parser that can map:
+      - "int"   -> int
+      - "float" -> float
+      - "str"   -> str
+      - "list[str]" -> List[str]
+      - ...
+    Expand this as needed for more advanced usage.
+    """
+    type_str = type_str.strip().lower()
+    if type_str == "int":
+        return int
+    elif type_str == "float":
+        return float
+    elif type_str == "str":
+        return str
+    elif type_str == "list":
+        return List[Any]
+    elif type_str.startswith("list["):
+        # e.g. "list[str]" or "list[int]" etc.
+        inner = type_str[len("list["):-1].strip()
+        return List[_parse_type_string(inner)]
+    # If none matched, return a very permissive type or raise an error
+    return Any
+
+
+def create_dict_response(
+    answer_keys: List[str],
+    value_types: List[str],
+    permissive: bool = False,
+) -> Type[BaseModel]:
+    """
+    Dynamically builds a Pydantic model that has:
+      - an `answer` submodel containing your required keys
+      - an optional `comment` field
+
+    If `permissive=False`, extra keys in `answer` are forbidden.
+    If `permissive=True`,  extra keys in `answer` are allowed.
+    """
+
+    # 1) Build the 'answer' submodel fields
+    #    Each key is required (using `...`), with the associated type from value_types.
+    field_definitions = {}
+    for key, t_str in zip(answer_keys, value_types):
+        python_type = _parse_type_string(t_str)
+        field_definitions[key] = (python_type, Field(...))
+
+    # Use Pydantic's create_model to construct an "AnswerSubModel" with these fields
+    AnswerSubModel = create_model(
+        "AnswerSubModel",
+        __base__=BaseModel,
+        **field_definitions
+    )
+
+    # 2) Define the top-level model with `answer` + optional `comment`
+    class DictResponse(BaseModel):
+        answer: AnswerSubModel
+        comment: Optional[str] = None
+        generated_tokens: Optional[Any] = Field(None)
+
+        class Config:
+            # If permissive=False, forbid extra keys in `answer`
+            # If permissive=True, allow them
+            extra = "allow" if permissive else "forbid"
+
+    return DictResponse
+
+
 class DictResponseValidator(ResponseValidatorABC):
+    """Optional placeholder if you still want a validator class around it."""
     required_params = ["answer_keys", "permissive"]
 
     valid_examples = [
@@ -42,17 +124,19 @@ class DictResponseValidator(ResponseValidatorABC):
         ),
         (
             {"answer": {"ingredients": "milk"}},  # Should be a list
-            {"answer_keys": ["ingredients"], "value_types": ["list"]},
+            {"answer_keys": ["ingredients"], "value_types": ["list[str]"]},
             "Key 'ingredients' should be a list, got str",
         )
     ]
 
 
 class QuestionDict(QuestionBase):
-    """ A QuestionDict allows you to create questions that expect dictionary responses with specific keys and value types.
+    """A QuestionDict allows you to create questions that expect dictionary responses
+    with specific keys and value types. It dynamically builds a pydantic model
+    so that Pydantic automatically raises ValidationError for missing/invalid fields.
+
+    Documentation: https://docs.expectedparrot.com/en/latest/questions.html#questiondict
 
-    Documenation: https://docs.expectedparrot.com/en/latest/questions.html#questiondict
-    
     Parameters
     ----------
     question_name : str
@@ -73,16 +157,8 @@ class QuestionDict(QuestionBase):
         Additional instructions for answering
     permissive : bool
         If True, allows additional keys not specified in answer_keys
-
-    Examples
-    --------
-    >>> q = QuestionDict(
-    ...     question_name="tweet",
-    ...     question_text="Draft a tweet.",
-    ...     answer_keys=["text", "characters"],
-    ...     value_descriptions=["The text of the tweet", "The number of characters in the tweet"]
-    ... )
     """
+
     question_type = "dict"
     question_text: str = QuestionTextDescriptor()
     answer_keys: List[str] = AnswerKeysDescriptor()
@@ -92,121 +168,6 @@ class QuestionDict(QuestionBase):
     _response_model = None
     response_validator_class = DictResponseValidator
 
-    def _get_default_answer(self) -> Dict[str, Any]:
-        """Get default answer based on types."""
-        answer = {}
-        if not self.value_types:
-            return {
-                "title": "Sample Recipe",
-                "ingredients": ["ingredient1", "ingredient2"],
-                "num_ingredients": 2,
-                "instructions": "Sample instructions"
-            }
-
-        for key, type_str in zip(self.answer_keys, self.value_types):
-            if type_str.startswith(('list[', 'list')):
-                if '[' in type_str:
-                    element_type = type_str[type_str.index('[') + 1:type_str.rindex(']')].lower()
-                    if element_type == 'str':
-                        answer[key] = ["sample_string"]
-                    elif element_type == 'int':
-                        answer[key] = [1]
-                    elif element_type == 'float':
-                        answer[key] = [1.0]
-                    else:
-                        answer[key] = []
-                else:
-                    answer[key] = []
-            else:
-                if type_str == 'str':
-                    answer[key] = "sample_string"
-                elif type_str == 'int':
-                    answer[key] = 1
-                elif type_str == 'float':
-                    answer[key] = 1.0
-                else:
-                    answer[key] = None
-                    
-        return answer
-
-    def create_response_model(
-        self,
-    ) -> Type[BaseModel]:
-        """Create a response model for dict questions."""
-        default_answer = self._get_default_answer()
-        
-        class DictResponse(BaseModel):
-            answer: Dict[str, Any] = Field(
-                default_factory=lambda: default_answer.copy()
-            )
-            comment: Optional[str] = None
-            
-            @field_validator("answer")
-            def validate_answer(cls, v, values, **kwargs):
-                # Ensure all keys exist
-                missing_keys = set(self.answer_keys) - set(v.keys())
-                if missing_keys:
-                    raise ValueError(f"Missing required keys: {missing_keys}")
-                    
-                # Validate value types if not permissive
-                if not self.permissive and self.value_types:
-                    for key, type_str in zip(self.answer_keys, self.value_types):
-                        if key not in v:
-                            continue
-                            
-                        value = v[key]
-                        type_str = type_str.lower()  # Normalize to lowercase
-                        
-                        # Handle list types
-                        if type_str.startswith(('list[', 'list')):
-                            if not isinstance(value, list):
-                                raise ValueError(f"Key '{key}' should be a list, got {type(value).__name__}")
-                                
-                            # If it's a parameterized list, check element types
-                            if '[' in type_str:
-                                element_type = type_str[type_str.index('[') + 1:type_str.rindex(']')]
-                                element_type = element_type.lower().strip()
-                                
-                                for i, elem in enumerate(value):
-                                    expected_type = {
-                                        'str': str,
-                                        'int': int,
-                                        'float': float,
-                                        'list': list
-                                    }.get(element_type)
-                                    
-                                    if expected_type and not isinstance(elem, expected_type):
-                                        raise ValueError(
-                                            f"List element at index {i} for key '{key}' "
-                                            f"has type {type(elem).__name__}, expected {element_type}"
-                                        )
-                        else:
-                            # Handle basic types
-                            expected_type = {
-                                'str': str,
-                                'int': int,
-                                'float': float,
-                                'list': list,
-                            }.get(type_str)
-                            
-                            if expected_type and not isinstance(value, expected_type):
-                                raise ValueError(
-                                    f"Key '{key}' has value of type {type(value).__name__}, expected {type_str}"
-                                )
-                return v
-
-            model_config = {
-                "json_schema_extra": {
-                    "examples": [{
-                        "answer": default_answer,
-                        "comment": None
-                    }]
-                }
-            }
-
-        DictResponse.__name__ = "DictResponse"
-        return DictResponse
-
     def __init__(
         self,
         question_name: str,
@@ -243,67 +204,54 @@ class QuestionDict(QuestionBase):
                 "Length of value_descriptions must match length of answer_keys."
             )
 
-    @staticmethod
-    def _normalize_value_types(value_types: Optional[List[Union[str, type]]]) -> Optional[List[str]]:
-        """Convert all value_types to string representations, including type hints."""
-        if not value_types:
-            return None
-
-        def normalize_type(t) -> str:
-            # Handle string representations of List
-            t_str = str(t)
-            if t_str == 'List':
-                return 'list'
-                
-            # Handle string inputs
-            if isinstance(t, str):
-                t = t.lower()
-                # Handle list types
-                if t.startswith(('list[', 'list')):
-                    if '[' in t:
-                        # Normalize the inner type
-                        inner_type = t[t.index('[') + 1:t.rindex(']')].strip().lower()
-                        return f"list[{inner_type}]"
-                    return "list"
-                return t
-
-            # Handle List the same as list
-            if t_str == "<class 'List'>":
-                return "list"
-
-            # If it's list type
-            if t is list:
-                return "list"
-
-            # If it's a basic type
-            if hasattr(t, "__name__"):
-                return t.__name__.lower()
-            
-            # If it's a typing.List
-            if t_str.startswith(('list[', 'list')):
-                return t_str.replace('typing.', '').lower()
-
-            # Handle generic types
-            if hasattr(t, "__origin__"):
-                origin = t.__origin__.__name__.lower()
-                args = [
-                    arg.__name__.lower() if hasattr(arg, "__name__") else str(arg).lower()
-                    for arg in t.__args__
-                ]
-                return f"{origin}[{', '.join(args)}]"
+    def create_response_model(self) -> Type[BaseModel]:
+        """
+        Build and return the Pydantic model that should parse/validate user answers.
+        This is similar to `QuestionNumerical.create_response_model`, but for dicts.
+        """
+        return create_dict_response(
+            answer_keys=self.answer_keys,
+            value_types=self.value_types or [],
+            permissive=self.permissive
+        )
 
-            raise QuestionCreationValidationError(
-                f"Invalid type in value_types: {t}. Must be a type or string."
-            )
+    def _get_default_answer(self) -> Dict[str, Any]:
+        """Build a default example answer based on the declared types."""
+        if not self.value_types:
+            # If user didn't specify types, return some default structure
+            return {
+                "title": "Sample Recipe",
+                "ingredients": ["ingredient1", "ingredient2"],
+                "num_ingredients": 2,
+                "instructions": "Sample instructions"
+            }
 
-        normalized = []
-        for t in value_types:
-            try:
-                normalized.append(normalize_type(t))
-            except Exception as e:
-                raise QuestionCreationValidationError(f"Error normalizing type {t}: {str(e)}")
-        
-        return normalized
+        answer = {}
+        for key, type_str in zip(self.answer_keys, self.value_types):
+            t_str = type_str.lower()
+            if t_str.startswith("list["):
+                # e.g. list[str], list[int], etc.
+                inner = t_str[len("list["):-1].strip()
+                if inner == "str":
+                    answer[key] = ["sample_string"]
+                elif inner == "int":
+                    answer[key] = [1]
+                elif inner == "float":
+                    answer[key] = [1.0]
+                else:
+                    answer[key] = []
+            elif t_str == "str":
+                answer[key] = "sample_string"
+            elif t_str == "int":
+                answer[key] = 1
+            elif t_str == "float":
+                answer[key] = 1.0
+            elif t_str == "list":
+                answer[key] = []
+            else:
+                # fallback
+                answer[key] = None
+        return answer
 
     def _render_template(self, template_name: str) -> str:
         """Render a template using Jinja."""
@@ -322,6 +270,34 @@ class QuestionDict(QuestionBase):
         except TemplateNotFound:
             return f"Template {template_name} not found in {template_dir}."
 
+    @staticmethod
+    def _normalize_value_types(value_types: Optional[List[Union[str, type]]]) -> Optional[List[str]]:
+        """
+        Convert all value_types to string representations (e.g. "int", "list[str]", etc.).
+        This logic is similar to your original approach but expanded to handle
+        python `type` objects as well as string hints.
+        """
+        if not value_types:
+            return None
+
+        def normalize_type(t) -> str:
+            # Already a string?
+            if isinstance(t, str):
+                return t.lower().strip()
+
+            # It's a Python built-in type?
+            if hasattr(t, "__name__"):
+                if t.__name__ == "List":
+                    return "list"
+                # For int, float, str, etc.
+                return t.__name__.lower()
+
+            # If it's a generic type like List[str], parse from its __origin__ / __args__
+            # or fallback:
+            return str(t).lower()
+
+        return [normalize_type(t) for t in value_types]
+
     def to_dict(self, add_edsl_version: bool = True) -> dict:
         """Serialize to JSON-compatible dictionary."""
         return {
@@ -366,12 +342,13 @@ class QuestionDict(QuestionBase):
         )
 
     def _simulate_answer(self) -> dict:
-            """Simulate an answer for the question."""
-            return {
-                "answer": self._get_default_answer(),
-                "comment": None
-            }
+        """Simulate an answer for the question."""
+        return {
+            "answer": self._get_default_answer(),
+            "comment": None
+        }
+
 
 if __name__ == "__main__":
     q = QuestionDict.example()
-    print(q.to_dict())
+    print(q.to_dict())

edsl/questions/question_extract.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import json
 import re
 from typing import Dict, Any
-from typing import Any, Optional, Dict
+from typing import Optional
 
 from pydantic import create_model, Field
 

edsl/questions/question_free_text.py

@@ -1,14 +1,11 @@
 from __future__ import annotations
-from typing import Any, Optional
-from typing import Optional, Any, List
+from typing import Optional
 
 from uuid import uuid4
 
-from pydantic import field_validator, model_validator, BaseModel
+from pydantic import model_validator, BaseModel
 
-from ..prompts import Prompt
 
-from .exceptions import QuestionAnswerValidationError
 from .question_base import QuestionBase
 from .response_validator_abc import ResponseValidatorABC
 from .decorators import inject_exception
@@ -48,7 +45,8 @@ class FreeTextResponse(BaseModel):
         if self.generated_tokens is not None:  # If generated_tokens exists
             # Ensure exact string equality
             if self.answer.strip() != self.generated_tokens.strip():  # They MUST match exactly
-                raise ValueError(
+                from .exceptions import QuestionAnswerValidationError
+                raise QuestionAnswerValidationError(
                     f"answer '{self.answer}' must exactly match generated_tokens '{self.generated_tokens}'. "
                     f"Type of answer: {type(self.answer)}, Type of tokens: {type(self.generated_tokens)}"
                 )

edsl/questions/question_functional.py

@@ -5,7 +5,6 @@ import inspect
 from .question_base import QuestionBase
 
 from ..utilities.restricted_python import create_restricted_function
-from ..utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 class QuestionFunctional(QuestionBase):
@@ -99,11 +98,13 @@ class QuestionFunctional(QuestionBase):
 
     def _simulate_answer(self, human_readable=True) -> dict[str, str]:
         """Required by Question, but not used by QuestionFunctional."""
-        raise NotImplementedError
+        from .exceptions import QuestionNotImplementedError
+        raise QuestionNotImplementedError("_simulate_answer not implemented for QuestionFunctional")
 
     def _validate_answer(self, answer: dict[str, str]):
         """Required by Question, but not used by QuestionFunctional."""
-        raise NotImplementedError
+        from .exceptions import QuestionNotImplementedError
+        raise QuestionNotImplementedError("_validate_answer not implemented for QuestionFunctional")
 
     @property
     def question_html_content(self) -> str: