edsl 0.1.33__py3-none-any.whl → 0.1.33.dev2__py3-none-any.whl

edsl/questions/QuestionBudget.py

@@ -1,60 +1,8 @@
 from __future__ import annotations
-from typing import Any, Optional, Union, List
-
-from pydantic import Field, BaseModel, validator
-
+import random
+from typing import Any, Optional, Union
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import IntegerDescriptor, QuestionOptionsDescriptor
-from edsl.questions.ResponseValidatorABC import ResponseValidatorABC
-
-
-class BudgewResponseValidator(ResponseValidatorABC):
-    valid_examples = []
-
-    invalid_examples = []
-
-    def fix(self, response, verbose=False):
-        if verbose:
-            print(f"Fixing list response: {response}")
-        answer = str(response.get("answer") or response.get("generated_tokens", ""))
-        if len(answer.split(",")) > 0:
-            return (
-                {"answer": answer.split(",")} | {"comment": response.get("comment")}
-                if "comment" in response
-                else {}
-            )
-
-
-def create_budget_model(
-    budget_sum: float, permissive: bool, question_options: List[str]
-):
-    class BudgetResponse(BaseModel):
-        answer: List[float] = Field(
-            ...,
-            description="List of non-negative numbers representing budget allocation",
-            min_items=len(question_options),
-            max_items=len(question_options),
-        )
-        comment: Optional[str] = None
-        generated_tokens: Optional[str] = None
-
-        @validator("answer")
-        def validate_answer(cls, v):
-            if len(v) != len(question_options):
-                raise ValueError(f"Must provide {len(question_options)} values")
-            if any(x < 0 for x in v):
-                raise ValueError("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}")
-            elif permissive and total > budget_sum:
-                raise ValueError(f"Sum of numbers cannot exceed {budget_sum}")
-            return v
-
-        class Config:
-            extra = "forbid"
-
-    return BudgetResponse
 
 
 class QuestionBudget(QuestionBase):
@@ -64,7 +12,7 @@ class QuestionBudget(QuestionBase):
     budget_sum: int = IntegerDescriptor(none_allowed=False)
     question_options: list[str] = QuestionOptionsDescriptor(q_budget=True)
     _response_model = None
-    response_validator_class = BudgewResponseValidator
+    response_validator_class = None
 
     def __init__(
         self,
@@ -72,10 +20,8 @@ class QuestionBudget(QuestionBase):
         question_text: str,
         question_options: list[str],
         budget_sum: int,
-        include_comment: bool = True,
         question_presentation: Optional[str] = None,
         answering_instructions: Optional[str] = None,
-        permissive: bool = False,
     ):
         """Instantiate a new QuestionBudget.
 
@@ -90,17 +36,20 @@ class QuestionBudget(QuestionBase):
         self.budget_sum = budget_sum
         self.question_presentation = question_presentation
         self.answering_instructions = answering_instructions
-        self.permissive = permissive
-        self.include_comment = include_comment
 
-    def create_response_model(self):
-        return create_budget_model(
-            self.budget_sum, self.permissive, self.question_options
-        )
+    ################
+    # Answer methods
+    ################
+    def _validate_answer(self, answer: dict[str, Any]) -> dict[str, Union[int, str]]:
+        """Validate the answer."""
+        self._validate_answer_template_basic(answer)
+        self._validate_answer_key_value(answer, "answer", dict)
+        self._validate_answer_budget(answer)
+        return answer
 
     def _translate_answer_code_to_answer(
-        self, answer_code, combined_dict
-    ) -> list[dict]:
+        self, answer_codes: dict[str, int], scenario: "Scenario" = None
+    ):
         """
         Translate the answer codes to the actual answers.
 
@@ -109,35 +58,35 @@ class QuestionBudget(QuestionBase):
         This code will translate that to "a".
         """
         translated_codes = []
-        for answer_code, question_option in zip(answer_code, self.question_options):
-            translated_codes.append({question_option: answer_code})
+        for answer_code, response in answer_codes.items():
+            translated_codes.append({self.question_options[int(answer_code)]: response})
 
         return translated_codes
 
-    # def _simulate_answer(self, human_readable=True):
-    #     """Simulate a valid answer for debugging purposes (what the validator expects)."""
-    #     from edsl.utilities.utilities import random_string
-
-    #     if human_readable:
-    #         keys = self.question_options
-    #     else:
-    #         keys = range(len(self.question_options))
-    #     remaining_budget = self.budget_sum
-    #     values = []
-    #     for _ in range(len(self.question_options)):
-    #         if _ == len(self.question_options) - 1:
-    #             # Assign remaining budget to the last value
-    #             values.append(remaining_budget)
-    #         else:
-    #             # Generate a random value between 0 and remaining budget
-    #             value = random.randint(0, remaining_budget)
-    #             values.append(value)
-    #             remaining_budget -= value
-    #     answer = dict(zip(keys, values))
-    #     return {
-    #         "answer": answer,
-    #         "comment": random_string(),
-    #     }
+    def _simulate_answer(self, human_readable=True):
+        """Simulate a valid answer for debugging purposes (what the validator expects)."""
+        from edsl.utilities.utilities import random_string
+
+        if human_readable:
+            keys = self.question_options
+        else:
+            keys = range(len(self.question_options))
+        remaining_budget = self.budget_sum
+        values = []
+        for _ in range(len(self.question_options)):
+            if _ == len(self.question_options) - 1:
+                # Assign remaining budget to the last value
+                values.append(remaining_budget)
+            else:
+                # Generate a random value between 0 and remaining budget
+                value = random.randint(0, remaining_budget)
+                values.append(value)
+                remaining_budget -= value
+        answer = dict(zip(keys, values))
+        return {
+            "answer": answer,
+            "comment": random_string(),
+        }
 
     @property
     def question_html_content(self) -> str:
@@ -184,14 +133,13 @@ class QuestionBudget(QuestionBase):
     # Helpful methods
     ################
     @classmethod
-    def example(cls, include_comment: bool = True) -> QuestionBudget:
+    def example(cls) -> QuestionBudget:
         """Return an example of a budget question."""
         return cls(
             question_name="food_budget",
             question_text="How would you allocate $100?",
             question_options=["Pizza", "Ice Cream", "Burgers", "Salad"],
             budget_sum=100,
-            include_comment=include_comment,
         )
 
 

edsl/questions/QuestionFreeText.py

@@ -36,12 +36,6 @@ class FreeTextResponseValidator(ResponseValidatorABC):
         ),
     ]
 
-    def fix(self, response, verbose=False):
-        return {
-            "answer": str(response.get("generated_tokens")),
-            "generated_tokens": str(response.get("generated_tokens")),
-        }
-
 
 class QuestionFreeText(QuestionBase):
     """This question prompts the agent to respond with free text."""

edsl/questions/QuestionMultipleChoice.py

@@ -1,14 +1,22 @@
 from __future__ import annotations
-from typing import Union, Literal, Optional, List, Any
-
+from typing import Union, Literal, Optional
 from jinja2 import Template
+
 from pydantic import BaseModel, Field
+from typing import Optional, Literal
 
-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.ResponseValidatorABC import ResponseValidatorABC
+from edsl.questions.ResponseValidatorABC import BaseResponse
+
+from edsl.exceptions import QuestionAnswerValidationError
+
+from pydantic import BaseModel, Field, create_model
+
+from typing import List, Any, Literal
 
 
 def create_response_model(choices: List[str], permissive: bool = False):
@@ -19,6 +27,7 @@ def create_response_model(choices: List[str], permissive: bool = False):
     :param permissive: If True, any value will be accepted as an answer.
     :return: A new Pydantic model class.
     """
+    # Convert the choices list to a tuple for use with Literal
     choice_tuple = tuple(choices)
 
     if not permissive:
@@ -57,6 +66,16 @@ def create_response_model(choices: List[str], permissive: bool = False):
     return ChoiceResponse
 
 
+def fix_multiple_choice(response, question_options, use_code, verbose=False):
+    """Fix the response to a multiple choice question.
+    Respnse is a dictionary with keys:
+    - answer: the answer code
+    - generated_tokens: the generated tokens
+    - comment: the comment
+    """
+    pass
+
+
 class MultipleChoiceResponseValidator(ResponseValidatorABC):
     required_params = ["question_options", "use_code"]
 
@@ -142,11 +161,6 @@ class QuestionMultipleChoice(QuestionBase):
         :param question_name: The name of the question.
         :param question_text: The text of the question.
         :param question_options: The options the agent should select from.
-        :param include_comment: Whether to include a comment field.
-        :param use_code: Whether to use code for the options.
-        :param answering_instructions: Instructions for the question.
-        :param question_presentation: The presentation of the question.
-        :param permissive: Whether to force the answer to be one of the options.
 
         """
         self.question_name = question_name
@@ -188,6 +202,7 @@ class QuestionMultipleChoice(QuestionBase):
         'Happy'
 
         """
+        from edsl.scenarios.Scenario import Scenario
 
         scenario = scenario or Scenario()
 

edsl/questions/QuestionNumerical.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
-
-# from decimal import Decimal
+from decimal import Decimal
 from random import uniform
 from typing import Any, Optional, Union, Literal
 
@@ -15,8 +14,8 @@ from edsl.exceptions.questions import QuestionAnswerValidationError
 
 
 def create_numeric_response(
-    min_value: Optional[float] = None,
-    max_value: Optional[float] = None,
+    min_value: Optional[Decimal] = None,
+    max_value: Optional[Decimal] = None,
     permissive=False,
 ):
     field_kwargs = {}
@@ -28,7 +27,7 @@ def create_numeric_response(
             field_kwargs["le"] = max_value
 
     class ConstrainedNumericResponse(BaseModel):
-        answer: Union[int, float] = Field(**field_kwargs)
+        answer: Union[Decimal] = Field(**field_kwargs)
         comment: Optional[str] = Field(None)
         generated_tokens: Optional[Any] = Field(None)
 

edsl/questions/ResponseValidatorABC.py

@@ -1,7 +1,6 @@
 from abc import ABC, abstractmethod
 from pydantic import BaseModel, Field, field_validator
-
-# from decimal import Decimal
+from decimal import Decimal
 from typing import Optional, Any, List, TypedDict
 
 from edsl.exceptions import QuestionAnswerValidationError
@@ -65,7 +64,7 @@ class ResponseValidatorABC(ABC):
         >>> rv = ResponseValidatorABC.example()
         >>> rv.override_answer = {"answer": 42}
         >>> rv.validate({"answer": 23})
-        {'answer': 42, 'comment': None, 'generated_tokens': None}
+        {'answer': Decimal('42'), 'comment': None, 'generated_tokens': None}
         """
         if self.exception_to_throw:
             raise self.exception_to_throw
@@ -76,7 +75,7 @@ class ResponseValidatorABC(ABC):
 
         >>> rv = ResponseValidatorABC.example("numerical")
         >>> rv._base_validate({"answer": 42})
-        ConstrainedNumericResponse(answer=42, comment=None, generated_tokens=None)
+        ConstrainedNumericResponse(answer=Decimal('42'), comment=None, generated_tokens=None)
         """
         try:
             return self.response_model(**data)
@@ -98,7 +97,7 @@ class ResponseValidatorABC(ABC):
 
         >>> rv = ResponseValidatorABC.example("numerical")
         >>> rv.validate({"answer": 42})
-        {'answer': 42, 'comment': None, 'generated_tokens': None}
+        {'answer': Decimal('42'), 'comment': None, 'generated_tokens': None}
         >>> rv.max_value
         86.7
         >>> rv.validate({"answer": "120"})
@@ -110,7 +109,7 @@ class ResponseValidatorABC(ABC):
         >>> q.permissive = True
         >>> rv = q.response_validator
         >>> rv.validate({"answer": "120"})
-        {'answer': 120, 'comment': None, 'generated_tokens': None}
+        {'answer': Decimal('120'), 'comment': None, 'generated_tokens': None}
         >>> rv.validate({"answer": "poo"})
         Traceback (most recent call last):
         ...

edsl/questions/derived/QuestionLinearScale.py

@@ -22,7 +22,6 @@ class QuestionLinearScale(QuestionMultipleChoice):
         option_labels: Optional[dict[int, str]] = None,
         answering_instructions: Optional[str] = None,
         question_presentation: Optional[str] = None,
-        include_comment: Optional[bool] = True,
     ):
         """Instantiate a new QuestionLinearScale.
 
@@ -37,7 +36,6 @@ class QuestionLinearScale(QuestionMultipleChoice):
             question_text=question_text,
             question_options=question_options,
             use_code=False,  # question linear scale will have it's own code
-            include_comment=include_comment,
         )
         self.question_options = question_options
         self.option_labels = (
@@ -51,14 +49,13 @@ class QuestionLinearScale(QuestionMultipleChoice):
     ################
     @classmethod
     @inject_exception
-    def example(cls, include_comment: bool = True) -> QuestionLinearScale:
+    def example(cls) -> QuestionLinearScale:
         """Return an example of a linear scale question."""
         return cls(
             question_text="How much do you like ice cream?",
             question_options=[1, 2, 3, 4, 5],
             question_name="ice_cream",
             option_labels={1: "I hate it", 5: "I love it"},
-            include_comment=include_comment,
         )
 
 

edsl/questions/derived/QuestionTopK.py

@@ -20,7 +20,6 @@ class QuestionTopK(QuestionCheckBox):
         max_selections: int,
         question_presentation: Optional[str] = None,
         answering_instructions: Optional[str] = None,
-        include_comment: Optional[bool] = True,
     ):
         """Initialize the question.
 
@@ -38,7 +37,6 @@ class QuestionTopK(QuestionCheckBox):
             max_selections=max_selections,
             question_presentation=question_presentation,
             answering_instructions=answering_instructions,
-            include_comment=include_comment,
         )
         if min_selections != max_selections:
             raise QuestionCreationValidationError(
@@ -54,7 +52,7 @@ class QuestionTopK(QuestionCheckBox):
     ################
     @classmethod
     @inject_exception
-    def example(cls, include_comment: bool = True) -> QuestionTopK:
+    def example(cls) -> QuestionTopK:
         """Return an example question."""
         return cls(
             question_name="two_fruits",
@@ -62,7 +60,6 @@ class QuestionTopK(QuestionCheckBox):
             question_options=["apple", "banana", "carrot", "durian"],
             min_selections=2,
             max_selections=2,
-            include_comment=include_comment,
         )
 
 

edsl/questions/derived/QuestionYesNo.py

@@ -19,7 +19,6 @@ class QuestionYesNo(QuestionMultipleChoice):
         question_options: list[str] = ["No", "Yes"],
         answering_instructions: Optional[str] = None,
         question_presentation: Optional[str] = None,
-        include_comment: Optional[bool] = True,
     ):
         """Instantiate a new QuestionYesNo.
 
@@ -34,7 +33,6 @@ class QuestionYesNo(QuestionMultipleChoice):
             use_code=False,
             answering_instructions=answering_instructions,
             question_presentation=question_presentation,
-            include_comment=include_comment,
         )
         self.question_options = question_options
 
@@ -43,13 +41,9 @@ class QuestionYesNo(QuestionMultipleChoice):
     ################
     @classmethod
     @inject_exception
-    def example(cls, include_comment: bool = True) -> QuestionYesNo:
+    def example(cls) -> QuestionYesNo:
         """Return an example of a yes/no question."""
-        return cls(
-            question_name="is_it_equal",
-            question_text="Is 5 + 5 equal to 11?",
-            include_comment=include_comment,
-        )
+        return cls(question_name="is_it_equal", question_text="Is 5 + 5 equal to 11?")
 
 
 def main():

edsl/results/DatasetExportMixin.py

@@ -472,11 +472,7 @@ class DatasetExportMixin:
         from edsl import ScenarioList, Scenario
 
         list_of_dicts = self.to_dicts(remove_prefix=remove_prefix)
-        scenarios = []
-        for d in list_of_dicts:
-            scenarios.append(Scenario(d))
-        return ScenarioList(scenarios)
-        # return ScenarioList([Scenario(d) for d in list_of_dicts])
+        return ScenarioList([Scenario(d) for d in list_of_dicts])
 
     def to_agent_list(self, remove_prefix: bool = True):
         """Convert the results to a list of dictionaries, one per agent.

edsl/results/Result.py

@@ -367,7 +367,7 @@ class Result(Base, UserDict):
                 "raw_model_response", {"raw_model_response": "No raw model response"}
             ),
             question_to_attributes=json_dict.get("question_to_attributes", None),
-            generated_tokens=json_dict.get("generated_tokens", {}),
+            generated_tokens=json_dict.get("generated_tokens", None),
         )
         return result
 

edsl/results/Results.py

@@ -245,9 +245,7 @@ class Results(UserList, Mixins, Base):
         )
 
     def __repr__(self) -> str:
-        import reprlib
-
-        return f"Results(data = {reprlib.repr(self.data)}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
+        return f"Results(data = {self.data}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
 
     def _repr_html_(self) -> str:
         from IPython.display import HTML
@@ -1091,7 +1089,6 @@ class Results(UserList, Mixins, Base):
             stop_on_exception=True,
             skip_retry=True,
             raise_validation_errors=True,
-            disable_remote_inference=True,
         )
         return results
 

edsl/scenarios/FileStore.py

@@ -120,22 +120,14 @@ class FileStore(Scenario):
         return info
 
     @classmethod
-    def pull(cls, uuid, expected_parrot_url: Optional[str] = None):
-        scenario_version = Scenario.pull(uuid, expected_parrot_url=expected_parrot_url)
+    def pull(cls, uuid):
+        scenario_version = Scenario.pull(uuid)
         return cls.from_dict(scenario_version.to_dict())
 
 
 class CSVFileStore(FileStore):
-    def __init__(
-        self,
-        filename,
-        binary: Optional[bool] = None,
-        suffix: Optional[str] = None,
-        base64_string: Optional[str] = None,
-    ):
-        super().__init__(
-            filename, binary=binary, base64_string=base64_string, suffix=".csv"
-        )
+    def __init__(self, filename):
+        super().__init__(filename, suffix=".csv")
 
     @classmethod
     def example(cls):
@@ -155,16 +147,8 @@ class CSVFileStore(FileStore):
 
 
 class PDFFileStore(FileStore):
-    def __init__(
-        self,
-        filename,
-        binary: Optional[bool] = None,
-        suffix: Optional[str] = None,
-        base64_string: Optional[str] = None,
-    ):
-        super().__init__(
-            filename, binary=binary, base64_string=base64_string, suffix=".pdf"
-        )
+    def __init__(self, filename):
+        super().__init__(filename, suffix=".pdf")
 
     def view(self):
         pdf_path = self.to_tempfile()
@@ -241,16 +225,8 @@ class PDFFileStore(FileStore):
 
 
 class PNGFileStore(FileStore):
-    def __init__(
-        self,
-        filename,
-        binary: Optional[bool] = None,
-        suffix: Optional[str] = None,
-        base64_string: Optional[str] = None,
-    ):
-        super().__init__(
-            filename, binary=binary, base64_string=base64_string, suffix=".png"
-        )
+    def __init__(self, filename):
+        super().__init__(filename, suffix=".png")
 
     @classmethod
     def example(cls):
@@ -275,16 +251,8 @@ class PNGFileStore(FileStore):
 
 
 class SQLiteFileStore(FileStore):
-    def __init__(
-        self,
-        filename,
-        binary: Optional[bool] = None,
-        suffix: Optional[str] = None,
-        base64_string: Optional[str] = None,
-    ):
-        super().__init__(
-            filename, binary=binary, base64_string=base64_string, suffix=".sqlite"
-        )
+    def __init__(self, filename):
+        super().__init__(filename, suffix=".sqlite")
 
     @classmethod
     def example(cls):
@@ -297,8 +265,6 @@ class SQLiteFileStore(FileStore):
             c.execute("""CREATE TABLE stocks (date text)""")
             conn.commit()
 
-            return cls(f.name)
-
     def view(self):
         import subprocess
         import os
@@ -307,33 +273,6 @@ class SQLiteFileStore(FileStore):
         os.system(f"sqlite3 {sqlite_path}")
 
 
-class HTMLFileStore(FileStore):
-    def __init__(
-        self,
-        filename,
-        binary: Optional[bool] = None,
-        suffix: Optional[str] = None,
-        base64_string: Optional[str] = None,
-    ):
-        super().__init__(
-            filename, binary=binary, base64_string=base64_string, suffix=".html"
-        )
-
-    @classmethod
-    def example(cls):
-        import tempfile
-
-        with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as f:
-            f.write("<html><body><h1>Test</h1></body></html>".encode())
-            return cls(f.name)
-
-    def view(self):
-        import webbrowser
-
-        html_path = self.to_tempfile()
-        webbrowser.open("file://" + html_path)
-
-
 if __name__ == "__main__":
     # file_path = "../conjure/examples/Ex11-2.sav"
     # fs = FileStore(file_path)