edsl 0.1.35__py3-none-any.whl → 0.1.36__py3-none-any.whl

edsl/prompts/library/agent_instructions.py

@@ -1,38 +0,0 @@
-"""Agent instructions for a human agent."""
-
-import textwrap
-
-from edsl.prompts.Prompt import PromptBase
-from edsl.prompts.prompt_config import ComponentTypes
-
-# from edsl.enums import LanguageModelType
-
-
-class AgentInstruction(PromptBase):
-    """Agent instructions for a human agent."""
-
-    # model = LanguageModelType.GPT_3_5_Turbo.value
-    # from edsl import Model
-    # model = Model().model
-    model = "gpt-3.5-turbo"
-    component_type = ComponentTypes.AGENT_INSTRUCTIONS
-    default_instructions = textwrap.dedent(
-        """\
-    You are playing the role of a human answering survey questions.
-    Do not break character.
-    """
-    )
-
-
-# class AgentInstructionLlama(PromptBase):
-#     """Agent instructions for a human agent."""
-
-#     model = LanguageModelType.LLAMA_2_70B_CHAT_HF.value
-#     component_type = ComponentTypes.AGENT_INSTRUCTIONS
-#     default_instructions = textwrap.dedent(
-#         """\
-#     You are playing the role of a human answering questions.
-#     Do not break character.
-#     Only respond in JSON, with one answer formatted as specified.
-#     """
-#     )

edsl/prompts/library/agent_persona.py

@@ -1,21 +0,0 @@
-"""Agent persona for a human agent."""
-
-import textwrap
-
-from edsl.prompts.Prompt import PromptBase
-from edsl.prompts.prompt_config import ComponentTypes
-
-# from edsl.enums import LanguageModelType
-
-
-class AgentPersona(PromptBase):
-    """Agent persona for a human agent."""
-
-    model = "gpt-4-1106-preview"
-    component_type = ComponentTypes.AGENT_PERSONA
-    default_instructions = textwrap.dedent(
-        """\
-            You are an agent with the following persona:
-            {{ traits }}
-        """
-    )

edsl/prompts/library/question_budget.py

@@ -1,30 +0,0 @@
-"""Budget question instructions."""
-
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class Budget(QuestionInstuctionsBase):
-    """Budget question instructions."""
-
-    question_type = "budget"
-    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 as follows, with a dictionary for your "answer"
-        where the keys are the option numbers and the values are the amounts you want 
-        to allocate to the options, and the sum of the values is {{budget_sum}}:
-        {"answer": {<put dict of option numbers and allocation amounts here>},
-        "comment": "<put explanation here>"}
-        Example response for a budget of 100 and 4 options: 
-        {"answer": {"0": 25, "1": 25, "2": 25, "3": 25},
-        "comment": "I allocated 25 to each option."}
-        There must be an allocation listed for each item (including 0).
-        """
-    )

edsl/prompts/library/question_checkbox.py

@@ -1,38 +0,0 @@
-"""Checkbox question type."""
-
-import textwrap
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class CheckBox(QuestionInstuctionsBase):
-    """Checkbox question type."""
-
-    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):
-    """Top K question type."""
-
-    question_type = "top_k"

edsl/prompts/library/question_extract.py

@@ -1,23 +0,0 @@
-"""Extract question type."""
-
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class Extract(QuestionInstuctionsBase):
-    """Extract question type."""
-
-    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,18 +0,0 @@
-"""Free text question type."""
-
-import textwrap
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class FreeText(QuestionInstuctionsBase):
-    """Free text question type."""
-
-    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,24 +0,0 @@
-"""Linear scale question type."""
-
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class LinearScale(QuestionInstuctionsBase):
-    """Linear scale question type."""
-
-    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,26 +0,0 @@
-"""List question type."""
-
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class ListQuestion(QuestionInstuctionsBase):
-    """List question type."""
-
-    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,54 +0,0 @@
-"""Multiple choice question type."""
-
-import textwrap
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class MultipleChoiceTurbo(QuestionInstuctionsBase):
-    """Multiple choice question type."""
-
-    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):
-    """Multiple choice question type."""
-
-    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):
-    """Likert five question type."""
-
-    question_type = "likert_five"
-
-
-class YesNo(MultipleChoice):
-    """Yes/No question type."""
-
-    question_type = "yes_no"

edsl/prompts/library/question_numerical.py

@@ -1,35 +0,0 @@
-"""Numerical question type."""
-
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class Numerical(QuestionInstuctionsBase):
-    """Numerical question type."""
-
-    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,25 +0,0 @@
-"""Rank question type."""
-
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class Rank(QuestionInstuctionsBase):
-    """Rank question type."""
-
-    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,37 +0,0 @@
-"""This file contains the configuration for the prompt generation."""
-
-from enum import Enum
-
-NEGATIVE_INFINITY = float("-inf")
-
-
-class AttributeTypes(Enum):
-    """The types of attributes that a prompt can have."""
-
-    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,202 +0,0 @@
-"""This module contains the RegisterPromptsMeta metaclass, which is used to register prompts."""
-
-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.
-
-        Example usage:
-        >>> 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]]:
-        """Create a key for the prompt class.
-
-        This is a helper function.
-        """
-        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"]]:
-        """
-        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):
-        """Filter out the prompts that have a score of -inf."""
-        return [
-            (score, prompt)
-            for score, prompt in prompts_with_scores
-            if score > NEGATIVE_INFINITY
-        ]
-
-    @classmethod
-    def get_classes(cls, **kwargs):
-        """Return only the prompt classes and not the scores.
-
-        Public-facing function.
-        """
-        with_scores = cls._get_classes_with_scores(**kwargs)
-        return [prompt for _, prompt in with_scores]
-        # return with_scores
-
-    @classmethod
-    def _score(cls, kwargs, prompt):
-        """Score the prompt based on the attributes that match."""
-        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 the registry."""
-        return cls._registry
-
-
-get_classes = RegisterPromptsMeta.get_classes