edsl 0.1.15__py3-none-any.whl → 0.1.40__py3-none-any.whl

edsl/prompts/library/question_checkbox.py

@@ -1,32 +0,0 @@
-import textwrap
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class CheckBox(QuestionInstuctionsBase):
-    question_type = "checkbox"
-    model = "gpt-4-1106-preview"
-    default_instructions = textwrap.dedent(
-        """\
-        You are being asked the following question: {{question_text}}
-        The options are
-        {% for option in question_options %}
-        {{ loop.index0 }}: {{option}}
-        {% endfor %}
-        Return a valid JSON formatted like this, selecting only the number of the option:
-        {"answer": [<put comma-separated list of answer codes here>], "comment": "<put explanation here>"}
-        {% if min_selections != None and max_selections != None and min_selections == max_selections %}
-        You must select exactly {{min_selections}} options.
-        {% elif min_selections != None and max_selections != None %}
-        Minimum number of options that must be selected: {{min_selections}}.
-        Maximum number of options that must be selected: {{max_selections}}.
-        {% elif min_selections != None %}
-        Minimum number of options that must be selected: {{min_selections}}.
-        {% elif max_selections != None %}
-        Maximum number of options that must be selected: {{max_selections}}.
-        {% endif %}
-        """
-    )
-
-
-class TopK(CheckBox):
-    question_type = "top_k"

edsl/prompts/library/question_extract.py

@@ -1,19 +0,0 @@
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class Extract(QuestionInstuctionsBase):
-    question_type = "extract"
-    model = "gpt-4-1106-preview"
-    default_instructions = textwrap.dedent(
-        """\
-        You are given the following input: "{{question_text}}".
-        Create an ANSWER should be formatted like this: "{{ answer_template }}",
-        and it should have the same keys but values extracted from the input.
-        If the value of a key is not present in the input, fill with "null".
-        Return a valid JSON formatted like this:
-        {"answer": <put your ANSWER here>}
-        ONLY RETURN THE JSON, AND NOTHING ELSE.
-        """
-    )

edsl/prompts/library/question_freetext.py

@@ -1,14 +0,0 @@
-import textwrap
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class FreeText(QuestionInstuctionsBase):
-    question_type = "free_text"
-    model = "gpt-4-1106-preview"
-    default_instructions = textwrap.dedent(
-        """\
-        You are being asked the following question: {{question_text}}
-        Return a valid JSON formatted like this:
-        {"answer": "<put free text answer here>"}
-        """
-    )

edsl/prompts/library/question_linear_scale.py

@@ -1,20 +0,0 @@
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class LinearScale(QuestionInstuctionsBase):
-    question_type = "linear_scale"
-    model = "gpt-4-1106-preview"
-    default_instructions = textwrap.dedent(
-        """\
-        You are being asked the following question: {{question_text}}
-        The options are
-        {% for option in question_options %}
-        {{ loop.index0 }}: {{option}}
-        {% endfor %}
-        Return a valid JSON formatted like this, selecting only the code of the option (codes start at 0):
-        {"answer": <put answer code here>, "comment": "<put explanation here>"}
-        Only 1 option may be selected.
-        """
-    )

edsl/prompts/library/question_list.py

@@ -1,22 +0,0 @@
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class ListQuestion(QuestionInstuctionsBase):
-    question_type = "list"
-    model = "gpt-4-1106-preview"
-    default_instructions = textwrap.dedent(
-        """\
-        {{question_text}}
-
-        Your response should be only a valid JSON in the following format:
-        {
-            "answer": [<comma-separated list of responsive words or phrases as independent strings>],
-            "comment": "<put comment here>"
-        }
-        {% if max_list_items is not none %}
-        The list must not contain more than {{ max_list_items }} items.
-        {% endif %}
-    """
-    )

edsl/prompts/library/question_multiple_choice.py

@@ -1,44 +0,0 @@
-import textwrap
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class MultipleChoiceTurbo(QuestionInstuctionsBase):
-    question_type = "multiple_choice"
-    model = "gpt-3.5-turbo"
-    default_instructions = textwrap.dedent(
-        """\
-        You are being asked the following question: {{question_text}}
-        The options are
-        {% for option in question_options %}
-        {{ loop.index0 }}: {{option}}
-        {% endfor %}
-        Return a valid JSON formatted like this, selecting only the number of the option:
-        {"answer": <put answer code here>, "comment": "<put explanation here>"}
-        Only 1 option may be selected.
-        """
-    )
-
-
-class MultipleChoice(QuestionInstuctionsBase):
-    question_type = "multiple_choice"
-    model = "gpt-4-1106-preview"
-    default_instructions = textwrap.dedent(
-        """\
-        You are being asked the following question: {{question_text}}
-        The options are
-        {% for option in question_options %}
-        {{ loop.index0 }}: {{option}}
-        {% endfor %}
-        Return a valid JSON formatted like this, selecting only the number of the option:
-        {"answer": <put answer code here>, "comment": "<put explanation here>"}
-        Only 1 option may be selected.
-        """
-    )
-
-
-class LikertFive(MultipleChoice):
-    question_type = "likert_five"
-
-
-class YesNo(MultipleChoice):
-    question_type = "yes_no"

edsl/prompts/library/question_numerical.py

@@ -1,31 +0,0 @@
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class Numerical(QuestionInstuctionsBase):
-    question_type = "numerical"
-    model = "gpt-4-1106-preview"
-    default_instructions = textwrap.dedent(
-        """\
-        You are being asked a question that requires a numerical response
-        in the form of an integer or decimal (e.g., -12, 0, 1, 2, 3.45, ...).
-        Your response must be in the following format:
-        {"answer": "<your numerical answer here>", "comment": "<your explanation here"}
-        You must only include an integer or decimal in the quoted "answer" part of your response.
-        Here is an example of a valid response:
-        {"answer": "100", "comment": "This is my explanation..."}
-        Here is an example of a response that is invalid because the "answer" includes words:
-        {"answer": "I don't know.", "comment": "This is my explanation..."}
-        If your response is equivalent to zero, your formatted response should look like this:
-        {"answer": "0", "comment": "This is my explanation..."}
-
-        You are being asked the following question: {{question_text}}
-        {% if min_value is not none %}
-        Minimum answer value: {{min_value}}
-        {% endif %}
-        {% if max_value is not none %}
-        Maximum answer value: {{max_value}}
-        {% endif %}
-        """
-    )

edsl/prompts/library/question_rank.py

@@ -1,21 +0,0 @@
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class Rank(QuestionInstuctionsBase):
-    question_type = "rank"
-    model = "gpt-4-1106-preview"
-    default_instructions = textwrap.dedent(
-        """\
-        You are being asked the following question: {{question_text}}
-        The options are
-        {% for option in question_options %}
-        {{ loop.index0 }}: {{option}}
-        {% endfor %}
-        Return a valid JSON formatted like this, selecting the numbers of the options in order of preference,
-        with the most preferred option first, and the least preferred option last:
-        {"answer": [<put comma-separated list of answer codes here>], "comment": "<put explanation here>"}
-        Exactly {{num_selections}} options must be selected.
-        """
-    )

edsl/prompts/prompt_config.py

@@ -1,33 +0,0 @@
-from enum import Enum
-
-NEGATIVE_INFINITY = float("-inf")
-
-
-class AttributeTypes(Enum):
-    COMPONENT_TYPE = "component_type"
-    MODEL = "model"
-    QUESTION_TYPE = "question_type"
-
-
-class ComponentTypes(Enum):
-    """The types of attributes that a prompt can have"""
-
-    TEST = "test"
-    GENERIC = "generic"
-    QUESTION_DATA = "question_data"
-    QUESTION_INSTRUCTIONS = "question_instructions"
-    AGENT_INSTRUCTIONS = "agent_instructions"
-    AGENT_PERSONA = "agent_persona"
-    SURVEY_INSTRUCTIONS = "survey_instructions"
-    SURVEY_DATA = "survey_data"
-
-
-names_to_component_types = {v.value: v for k, v in ComponentTypes.__members__.items()}
-
-C2A = {
-    ComponentTypes.QUESTION_INSTRUCTIONS: [
-        AttributeTypes.QUESTION_TYPE,
-        AttributeTypes.MODEL,
-    ],
-    ComponentTypes.AGENT_INSTRUCTIONS: [AttributeTypes.MODEL],
-}

edsl/prompts/registry.py

@@ -1,185 +0,0 @@
-import traceback
-from collections import defaultdict
-from typing import List, Any
-
-from abc import ABCMeta, abstractmethod
-
-from edsl.prompts.prompt_config import (
-    C2A,
-    names_to_component_types,
-    ComponentTypes,
-    NEGATIVE_INFINITY,
-)
-
-from edsl.enums import QuestionType, LanguageModelType
-
-from edsl.exceptions.prompts import (
-    PromptBadQuestionTypeError,
-    PromptBadLanguageModelTypeError,
-)
-
-
-class RegisterPromptsMeta(ABCMeta):
-    "Metaclass to register prompts"
-    _registry = defaultdict(list)  # Initialize the registry as a dictionary
-    _prompts_by_component_type = defaultdict(list)
-    # _instances = {}
-
-    # def __new__(mcs, name, bases, dct):
-    #     if mcs not in mcs._instances:
-    #         mcs._instances[mcs] = super(RegisterPromptsMeta, mcs).__new__(
-    #             mcs, name, bases, dct
-    #         )
-    #     return mcs._instances[mcs]
-
-    def __init__(cls, name, bases, dct):
-        """
-        We can only have one prompt class per name.
-        Each prompt class must have a component type from the ComponentTypes enum.
-
-        >>> class Prompt1(PromptBase):
-        ...     component_type = ComponentTypes.TEST
-
-        >>> class Prompt1(PromptBase):
-        ...     component_type = ComponentTypes.TEST
-        Traceback (most recent call last):
-        ...
-        Exception: We already have a Prompt class named Prompt1.
-        """
-        super(RegisterPromptsMeta, cls).__init__(name, bases, dct)
-        # print(f"Current state of registry: {RegisterPromptsMeta._registry}")
-        # print(f"Registry called with {name}")
-        if "Base" in name or name == "Prompt":
-            # print("Exiting")
-            return None  # We don't want to register the base class
-
-        if name in RegisterPromptsMeta._registry:
-            if RegisterPromptsMeta._registry[name] != cls:
-                raise Exception(f"We already have a Prompt class named {name}.")
-            else:
-                # print("It's the same thing - it's fine.")
-                return None
-
-        RegisterPromptsMeta._registry[name] = cls
-        # print(f"Current registry: {RegisterPromptsMeta._registry}")
-        if (
-            component_type := getattr(cls, "component_type", None)
-        ) not in ComponentTypes:
-            raise Exception(f"Prompt {name} is not in the list of component types")
-
-        ## Make sure that the prompt has a question_type class attribute & it's valid
-        if component_type == ComponentTypes.QUESTION_INSTRUCTIONS:
-            if not hasattr(cls, "question_type"):
-                raise PromptBadQuestionTypeError(
-                    "A QuestionInstructions prompt must has a question_type value"
-                )
-            if not QuestionType.is_value_valid(cls.question_type):
-                acceptable_values = [item.value for item in QuestionType]
-                raise PromptBadQuestionTypeError(
-                    f"""
-                A Prompt's question_type must be one of {QuestionType} values, which are 
-                currently {acceptable_values}. You passed {cls.question_type}."""
-                )
-
-        ## Make sure that if the prompt has a model class attribute, it's valid
-        if hasattr(cls, "model"):
-            if not LanguageModelType.is_value_valid(cls.model):
-                acceptable_values = [item.value for item in LanguageModelType]
-                raise PromptBadLanguageModelTypeError(
-                    f"""
-                A Prompt's model must be one of {LanguageModelType} values, which are 
-                currently {acceptable_values}. You passed {cls.model}."""
-                )
-
-        key = cls._create_prompt_class_key(dct, component_type)
-        cls.data = key
-        RegisterPromptsMeta._prompts_by_component_type[component_type].append(cls)
-
-    @classmethod
-    def _create_prompt_class_key(cls, dct, component_type) -> tuple[tuple[str, Any]]:
-        attributes = [attribute.value for attribute in C2A.get(component_type, [])]
-        cls_data = {key: value for key, value in dct.items() if key in attributes}
-        return tuple(cls_data.items())
-
-    @classmethod
-    def _get_classes_with_scores(cls, **kwargs) -> List[tuple[float, "PromptBase"]]:
-        """
-        This how we find matching prompts.
-        NB that _get_classes_with_scores returns a list of tuples.
-        The first element of the tuple is the score, and the second element is the prompt class.
-        There is a public-facing function called get_classes that returns only the prompt classes.
-
-        The kwargs are the attributes that we want to match on. E.g., supposed you
-        wanted a prompt with component_type = "question_instructions" and question_type = "multiple_choice".
-        You would run:
-
-        >>> get_classes(component_type="question_instructions", question_type="multiple_choice", model="gpt-4-1106-preview")
-        [<class '__main__.MultipleChoice'>, <class '__main__.MultipleChoiceTurbo'>]
-
-        In the above example, we have two prompts that match. Note that the order of the prompts is determined by the score and the regular MultipleChoice
-        is ranked higher because it matches on the model as well.
-
-        Scores are computed by the _score method. The score is the number of attributes that match, with their weights.
-        However, if a required attribute doesn't match, then the score is -inf and it can never be selected.
-
-        The function will throw an exception if you don't specify a component type that's in the ComponentTypes enum.
-
-        >>> get_classes(component_type="chicken_tenders", question_type="multiple_choice")
-        Traceback (most recent call last):
-        ...
-        Exception: You must specify a component type. It must be one of dict_keys([...])
-
-        >>> get_classes(component_type="generic")
-        []
-        """
-        component_type_string = kwargs.get("component_type", None)
-        component_type = names_to_component_types.get(component_type_string, None)
-
-        if component_type is None:
-            raise Exception(
-                f"You must specify a component type. It must be one of {names_to_component_types.keys()}"
-            )
-
-        try:
-            prompts = cls._prompts_by_component_type[component_type]
-        except KeyError:
-            raise Exception(f"No prompts for component type {component_type}")
-
-        with_scores = [(cls._score(kwargs, prompt), prompt) for prompt in prompts]
-        with_scores = sorted(with_scores, key=lambda x: -x[0])
-        # filter out the ones with -inf
-        matches_with_scores = cls._filter_out_non_matches(with_scores)
-        return matches_with_scores
-
-    @classmethod
-    def _filter_out_non_matches(cls, prompts_with_scores):
-        return [
-            (score, prompt)
-            for score, prompt in prompts_with_scores
-            if score > NEGATIVE_INFINITY
-        ]
-
-    @classmethod
-    def get_classes(cls, **kwargs):
-        "Public-facing function that returns only the prompt classes and not the scores."
-        with_scores = cls._get_classes_with_scores(**kwargs)
-        return [prompt for _, prompt in with_scores]
-
-    @classmethod
-    def _score(cls, kwargs, prompt):
-        required_list = ["question_type"]
-        score = 0
-        for key, value in kwargs.items():
-            if prompt_value := getattr(prompt, key, None) == value:
-                score += 1
-            else:
-                if key in required_list:
-                    score += NEGATIVE_INFINITY
-        return score
-
-    @classmethod
-    def get_registered_classes(cls):
-        return cls._registry
-
-
-get_classes = RegisterPromptsMeta.get_classes

edsl/questions/Question.py

@@ -1,240 +0,0 @@
-from __future__ import annotations
-import textwrap
-import io
-from abc import ABC, abstractmethod, ABCMeta
-from rich.console import Console
-from rich.table import Table
-from jinja2 import Template, Environment, meta
-from typing import Any, Type
-from edsl.exceptions import (
-    QuestionResponseValidationError,
-    QuestionSerializationError,
-    QuestionScenarioRenderError,
-)
-from edsl.questions.descriptors import (
-    InstructionsDescriptor,
-    QuestionNameDescriptor,
-    QuestionTextDescriptor,
-    ShortNamesDictDescriptor,
-)
-
-from edsl.prompts.Prompt import Prompt
-
-from edsl.enums import QuestionType
-
-# from edsl.questions.question_registry import get_question_class
-from edsl.questions.AnswerValidatorMixin import AnswerValidatorMixin
-
-from edsl.exceptions.questions import QuestionMissingTypeError, QuestionBadTypeError
-
-
-class RegisterQuestionsMeta(ABCMeta):
-    "Metaclass to register output elements in a registry i.e., those that have a parent"
-    _registry = {}  # Initialize the registry as a dictionary
-
-    def __init__(cls, name, bases, dct):
-        super(RegisterQuestionsMeta, cls).__init__(name, bases, dct)
-        if name != "Question":
-            ## Enforce that all questions have a question_type class attribute
-            ## and it comes from our enum of valid question types.
-            if not hasattr(cls, "question_type"):
-                raise QuestionMissingTypeError(
-                    "Question must have a question_type class attribute"
-                )
-
-            if not QuestionType.is_value_valid(cls.question_type):
-                acceptable_values = [item.value for item in QuestionType]
-                raise QuestionBadTypeError(
-                    f"""question_type must be one of {QuestionType} values, which are 
-                                currently {acceptable_values}"""
-                    ""
-                )
-
-            RegisterQuestionsMeta._registry[name] = cls
-
-    @classmethod
-    def get_registered_classes(cls):
-        return cls._registry
-
-    @classmethod
-    def question_types_to_classes(
-        cls,
-    ):
-        d = {}
-        for classname, cls in cls._registry.items():
-            if hasattr(cls, "question_type"):
-                d[cls.question_type] = cls
-            else:
-                raise Exception(
-                    f"Class {classname} does not have a question_type class attribute"
-                )
-        return d
-
-
-from edsl.Base import PersistenceMixin, RichPrintingMixin
-
-
-class Question(
-    PersistenceMixin,
-    RichPrintingMixin,
-    ABC,
-    AnswerValidatorMixin,
-    metaclass=RegisterQuestionsMeta,
-):
-    """
-    ABC for the Question class. All questions should inherit from this class.
-    """
-
-    question_name: str = QuestionNameDescriptor()
-    question_text: str = QuestionTextDescriptor()
-    short_names_dict: dict[str, str] = ShortNamesDictDescriptor()
-
-    @property
-    def data(self) -> dict:
-        """Returns a dictionary of question attributes **except** for question_type"""
-        candidate_data = {
-            k.replace("_", "", 1): v
-            for k, v in self.__dict__.items()
-            if k.startswith("_")
-        }
-        optional_attributes = {
-            "set_instructions": "instructions",
-        }
-        for boolean_flag, attribute in optional_attributes.items():
-            if hasattr(self, boolean_flag) and not getattr(self, boolean_flag):
-                candidate_data.pop(attribute, None)
-
-        return candidate_data
-
-    ############################
-    # Serialization methods
-    ############################
-    def to_dict(self) -> dict[str, Any]:
-        """Converts the question to a dictionary that includes the question type (used in deserialization)."""
-        candidate_data = self.data.copy()
-        candidate_data["question_type"] = self.question_type
-        return candidate_data
-
-    @classmethod
-    def from_dict(cls, data: dict) -> Type[Question]:
-        """Constructs a question object from a dictionary created by that question's `to_dict` method."""
-        local_data = data.copy()
-        try:
-            question_type = local_data.pop("question_type")
-        except:
-            raise QuestionSerializationError(
-                f"Data does not have a 'question_type' field (got {data})."
-            )
-        from edsl.questions.question_registry import get_question_class
-
-        try:
-            question_class = get_question_class(question_type)
-        except ValueError:
-            raise QuestionSerializationError(
-                f"No question registered with question_type {question_type}"
-            )
-        return question_class(**local_data)
-
-    ############################
-    # Dunder methods
-    ############################
-    def __repr__(self) -> str:
-        """Returns a string representation of the question. Should be able to be used to reconstruct the question."""
-        class_name = self.__class__.__name__
-        items = [
-            f"{k} = '{v}'" if isinstance(v, str) else f"{k} = {v}"
-            for k, v in self.data.items()
-            if k != "question_type"
-        ]
-        return f"{class_name}({', '.join(items)})"
-
-    def __eq__(self, other: Type[Question]) -> bool:
-        """Checks if two questions are equal. Equality is defined as having the .to_dict()"""
-        if not isinstance(other, Question):
-            return False
-        return self.to_dict() == other.to_dict()
-
-    # TODO: Throws an error that should be addressed at QuestionFunctional
-    def __add__(self, other_question):
-        """
-        Composes two questions into a single question.
-        >>> from edsl.scenarios.Scenario import Scenario
-        >>> from edsl.questions.QuestionFreeText import QuestionFreeText
-        >>> from edsl.questions.QuestionNumerical import QuestionNumerical
-        >>> q1 = QuestionFreeText(question_text = "What is the capital of {{country}}", question_name = "capital")
-        >>> q2 = QuestionNumerical(question_text = "What is the population of {{capital}}, in millions. Please round", question_name = "population")
-        >>> q3 = q1 + q2
-        """
-        from edsl.questions import compose_questions
-
-        return compose_questions(self, other_question)
-
-    @abstractmethod
-    def validate_answer(self, answer: dict[str, str]):
-        pass
-
-    def validate_response(self, response):
-        """Validates the response from the LLM"""
-        if "answer" not in response:
-            raise QuestionResponseValidationError(
-                "Response from LLM does not have an answer"
-            )
-        return response
-
-    @abstractmethod
-    def translate_answer_code_to_answer(self):  # pragma: no cover
-        """Translates the answer code to the actual answer. Behavior depends on the question type."""
-        pass
-
-    @abstractmethod
-    def simulate_answer(self, human_readable=True) -> dict:  # pragma: no cover
-        """Simulates a valid answer for debugging purposes (what the validator expects)"""
-        pass
-
-    ############################
-    # Forward methods
-    ############################
-    def add_question(self, other):
-        "Adds a question to this question by turning them into a survey with two questions"
-        from edsl.surveys.Survey import Survey
-
-        s = Survey([self, other])
-        return s
-
-    def run(self, *args, **kwargs):
-        "Turns a single question into a survey and runs it."
-        from edsl.surveys.Survey import Survey
-
-        s = Survey([self])
-        return s.run(*args, **kwargs)
-
-    def by(self, *args):
-        "Documentation missing."
-        from edsl.surveys.Survey import Survey
-
-        s = Survey([self])
-        return s.by(*args)
-
-    def rich_print(self):
-        table = Table(show_header=True, header_style="bold magenta")
-        table.add_column("Question Name", style="dim")
-        table.add_column("Question Type")
-        table.add_column("Question Text")
-        table.add_column("Options")
-
-        question = self
-        if hasattr(question, "question_options"):
-            options = ", ".join([str(o) for o in question.question_options])
-        else:
-            options = "None"
-        table.add_row(
-            question.question_name,
-            question.question_type,
-            question.question_text,
-            options,
-        )
-        return table
-
-
-if __name__ == "__main__":
-    q = get_question_class("free_text")