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

edsl/jobs/token_tracking.py

@@ -1,78 +0,0 @@
-class TokenPricing:
-    def __init__(
-        self,
-        *,
-        model_name,
-        prompt_token_price_per_k: float,
-        completion_token_price_per_k: float,
-    ):
-        self.model_name = model_name
-        self.prompt_token_price = prompt_token_price_per_k / 1_000.0
-        self.completion_token_price = completion_token_price_per_k / 1_000.0
-
-    def __eq__(self, other):
-        if not isinstance(other, TokenPricing):
-            return False
-        return (
-            self.model_name == other.model_name
-            and self.prompt_token_price == other.prompt_token_price
-            and self.completion_token_price == other.completion_token_price
-        )
-
-
-class TokenUsage:
-    def __init__(
-        self, from_cache: bool, prompt_tokens: int = 0, completion_tokens: int = 0
-    ):
-        self.from_cache = from_cache
-        self.prompt_tokens = prompt_tokens
-        self.completion_tokens = completion_tokens
-
-    def add_tokens(self, prompt_tokens, completion_tokens):
-        self.prompt_tokens += prompt_tokens
-        self.completion_tokens += completion_tokens
-
-    def __add__(self, other):
-        if not isinstance(other, TokenUsage):
-            raise ValueError(f"Can't add {type(other)} to InterviewTokenUsage")
-        if self.from_cache != other.from_cache:
-            raise ValueError(f"Can't add token usages from different sources")
-        return TokenUsage(
-            from_cache=self.from_cache,
-            prompt_tokens=self.prompt_tokens + other.prompt_tokens,
-            completion_tokens=self.completion_tokens + other.completion_tokens,
-        )
-
-    def __repr__(self):
-        return f"TokenUsage(from_cache={self.from_cache}, prompt_tokens={self.prompt_tokens}, completion_tokens={self.completion_tokens})"
-
-    def cost(self, prices: TokenPricing):
-        return (
-            self.prompt_tokens * prices.prompt_token_price
-            + self.completion_tokens * prices.completion_token_price
-        )
-
-
-class InterviewTokenUsage:
-    def __init__(
-        self, new_token_usage: TokenUsage = None, cached_token_usage: TokenUsage = None
-    ):
-        self.new_token_usage = new_token_usage or TokenUsage(from_cache=False)
-        self.cached_token_usage = cached_token_usage or TokenUsage(from_cache=True)
-
-    def __add__(self, other):
-        if not isinstance(other, InterviewTokenUsage):
-            raise ValueError(f"Can't add {type(other)} to InterviewTokenSummary")
-        return InterviewTokenUsage(
-            new_token_usage=self.new_token_usage + other.new_token_usage,
-            cached_token_usage=self.cached_token_usage + other.cached_token_usage,
-        )
-
-    def __repr__(self):
-        return f"InterviewTokenUsage(new_token_usage={self.new_token_usage}, cached_token_usage={self.cached_token_usage})"
-
-    def cost(self, prices: TokenPricing):
-        return self.new_token_usage.cost(prices)
-
-    def saved(self, prices: TokenPricing):
-        return self.cached_token_usage.cost(prices)

edsl/language_models/DeepInfra.py

@@ -1,69 +0,0 @@
-import aiohttp
-import json
-from typing import Any
-from edsl import CONFIG
-from edsl.enums import LanguageModelType, InferenceServiceType
-from edsl.language_models.LanguageModel import LanguageModel
-
-
-def create_deep_infra_model(model_name, url, model_class_name) -> LanguageModel:
-    if not LanguageModelType.is_value_valid(model_name):
-        acceptable_values = [item.value for item in LanguageModelType]
-        raise Exception(
-            f"""
-        A Prompt's model must be one of {LanguageModelType} values, which are 
-        currently {acceptable_values}. You passed {model_name}."""
-        )
-
-    class LLM(LanguageModel):
-        _inference_service_ = InferenceServiceType.DEEP_INFRA.value
-        _model_ = model_name
-        _parameters_ = {
-            "temperature": 0.5,
-            "top_p": 1,
-            "top_k": 1,
-            "max_new_tokens": 2048,
-            "stopSequences": [],
-            "use_cache": True,
-        }
-        api_token = CONFIG.get("DEEP_INFRA_API_KEY")
-
-        async def async_execute_model_call(
-            self, user_prompt: str, system_prompt: str = ""
-        ) -> dict[str, Any]:
-            self.url = url
-            headers = {
-                "Content-Type": "application/json",
-                "Authorization": f"Token {self.api_token}",
-            }
-            data = {
-                "input": f"""
-                [INST]<<SYS>> {system_prompt} 
-                <<SYS>[/INST]
-                {user_prompt} [/INST]
-                """,
-                "stream": False,
-                "temperature": self.temperature,
-                "top_p": self.top_p,
-                "top_k": self.top_k,
-                "max_new_tokens": self.max_new_tokens,
-            }
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    self.url, headers=headers, data=json.dumps(data)
-                ) as response:
-                    raw_response_text = await response.text()
-                    return json.loads(raw_response_text)
-
-        def parse_response(self, raw_response: dict[str, Any]) -> str:
-            return raw_response["results"][0]["generated_text"]
-
-    LLM.__name__ = model_class_name
-
-    return LLM
-
-
-if __name__ == "__main__":
-    pass
-    # results = m.execute_model_call("Why is Cape Cod a popular vacation spot?")
-    # print(m.parse_response(results))

edsl/language_models/OpenAI.py

@@ -1,98 +0,0 @@
-import openai
-import re
-from typing import Any
-from edsl import CONFIG
-from openai import AsyncOpenAI
-from edsl.enums import LanguageModelType, InferenceServiceType
-from edsl.language_models import LanguageModel
-
-LanguageModelType.GPT_4.value
-
-
-def create_openai_model(model_name, model_class_name) -> LanguageModel:
-    openai.api_key = CONFIG.get("OPENAI_API_KEY")
-
-    class LLM(LanguageModel):
-        """
-        Child class of LanguageModel for interacting with OpenAI models
-        """
-
-        _inference_service_ = InferenceServiceType.OPENAI.value
-        _model_ = model_name
-        _parameters_ = {
-            "temperature": 0.5,
-            "max_tokens": 1000,
-            "top_p": 1,
-            "frequency_penalty": 0,
-            "presence_penalty": 0,
-            "use_cache": True,
-        }
-        client = AsyncOpenAI()
-
-        def get_headers(self) -> dict[str, Any]:
-            from openai import OpenAI
-
-            client = OpenAI()
-            response = client.chat.completions.with_raw_response.create(
-                messages=[
-                    {
-                        "role": "user",
-                        "content": "Say this is a test",
-                    }
-                ],
-                model=self.model,
-            )
-            return dict(response.headers)
-
-        def get_rate_limits(self) -> dict[str, Any]:
-            try:
-                headers = self.get_headers()
-            except Exception as e:
-                return {
-                    "rpm": 10_000,
-                    "tpm": 2_000_000,
-                }
-            else:
-                return {
-                    "rpm": int(headers["x-ratelimit-limit-requests"]),
-                    "tpm": int(headers["x-ratelimit-limit-tokens"]),
-                }
-
-        async def async_execute_model_call(
-            self, user_prompt: str, system_prompt: str = ""
-        ) -> dict[str, Any]:
-            """Calls the OpenAI API and returns the API response."""
-            response = await self.client.chat.completions.create(
-                model=self.model,
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": user_prompt},
-                ],
-                temperature=self.temperature,
-                max_tokens=self.max_tokens,
-                top_p=self.top_p,
-                frequency_penalty=self.frequency_penalty,
-                presence_penalty=self.presence_penalty,
-            )
-            return response.model_dump()
-
-        @staticmethod
-        def parse_response(raw_response: dict[str, Any]) -> str:
-            """Parses the API response and returns the response text."""
-            response = raw_response["choices"][0]["message"]["content"]
-            pattern = r"^```json(?:\\n|\n)(.+?)(?:\\n|\n)```$"
-            match = re.match(pattern, response, re.DOTALL)
-            if match:
-                return match.group(1)
-            else:
-                return response
-
-    LLM.__name__ = model_class_name
-
-    return LLM
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/language_models/model_interfaces/GeminiPro.py

@@ -1,66 +0,0 @@
-import aiohttp
-import json
-from typing import Any
-from edsl import CONFIG
-from edsl.language_models.LanguageModel import LanguageModel
-from edsl.enums import LanguageModelType, InferenceServiceType
-
-
-class GeminiPro(LanguageModel):
-    _inference_service_ = InferenceServiceType.GOOGLE.value
-    _model_ = LanguageModelType.GEMINI_PRO.value
-    _parameters_ = {
-        "temperature": 0.5,
-        "topP": 1,
-        "topK": 1,
-        "maxOutputTokens": 2048,
-        "stopSequences": [],
-        "use_cache": True,
-    }
-    api_token = CONFIG.get("GOOGLE_API_KEY")
-
-    async def async_execute_model_call(
-        self, user_prompt: str, system_prompt: str = ""
-    ) -> dict[str, Any]:
-        combined_prompt = user_prompt + system_prompt
-        url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key={self.api_token}"
-        headers = {"Content-Type": "application/json"}
-        data = {
-            "contents": [{"parts": [{"text": combined_prompt}]}],
-            "generationConfig": {
-                "temperature": self.temperature,
-                "topK": self.topK,
-                "topP": self.topP,
-                "maxOutputTokens": self.maxOutputTokens,
-                "stopSequences": self.stopSequences,
-            },
-        }
-
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                url, headers=headers, data=json.dumps(data)
-            ) as response:
-                raw_response_text = await response.text()
-                return json.loads(raw_response_text)
-
-    def parse_response(self, raw_response: dict[str, Any]) -> str:
-        data = raw_response
-        return data["candidates"][0]["content"]["parts"][0]["text"]
-
-
-if __name__ == "__main__":
-    m = GeminiPro(use_cache=True)
-    from edsl.questions import QuestionMultipleChoice
-
-    q = QuestionMultipleChoice(
-        question_text="Are pickled pigs feet a popular breakfast food in the US?",
-        question_options=["Yes", "No", "Unsure"],
-        question_name="bkfast_question",
-    )
-    results = q.by(m).run()
-    from rich import print
-
-    print(q)
-    results.select("answer.*", "model.model").print()
-    # results = m.execute_model_call("Why is Cape Cod a popular vacation spot?")
-    # print(m.parse_response(results))

edsl/language_models/model_interfaces/LanguageModelOpenAIFour.py

@@ -1,8 +0,0 @@
-from edsl.language_models.OpenAI import create_openai_model
-from edsl.enums import LanguageModelType
-
-model_name = LanguageModelType.GPT_4.value
-
-LanguageModelOpenAIFour = create_openai_model(
-    model_name=model_name, model_class_name="LanguageModelOpenAIFour"
-)

edsl/language_models/model_interfaces/LanguageModelOpenAIThreeFiveTurbo.py

@@ -1,8 +0,0 @@
-from edsl.language_models.OpenAI import create_openai_model
-from edsl.enums import LanguageModelType
-
-model_name = LanguageModelType.GPT_3_5_Turbo.value
-
-LanguageModelOpenAIThreeFiveTurbo = create_openai_model(
-    model_name=model_name, model_class_name="LanguageModelOpenAIThreeFiveTurbo"
-)

edsl/language_models/model_interfaces/LlamaTwo13B.py

@@ -1,21 +0,0 @@
-from edsl.language_models.DeepInfra import create_deep_infra_model
-from edsl.enums import LanguageModelType
-
-model_name = LanguageModelType.LLAMA_2_13B_CHAT_HF.value
-url = "https://api.deepinfra.com/v1/inference/meta-llama/Llama-2-13b-chat-hf"
-
-LlamaTwo13B = create_deep_infra_model(
-    model_name=model_name, url=url, model_class_name="LlamaTwo13B"
-)
-
-if __name__ == "__main__":
-    model = LlamaTwo13B(use_cache=False)
-    from edsl.questions import QuestionMultipleChoice
-
-    q = QuestionMultipleChoice(
-        question_text="Are pickled pigs feet a popular breakfast food in the US?",
-        question_options=["Yes", "No", "Unsure"],
-        question_name="bkfast_question",
-    )
-    results = q.by(model).run()
-    results.select("answer.*", "model.model").print()

edsl/language_models/model_interfaces/LlamaTwo70B.py

@@ -1,21 +0,0 @@
-from edsl.language_models.DeepInfra import create_deep_infra_model
-from edsl.enums import LanguageModelType
-
-model_name = LanguageModelType.LLAMA_2_70B_CHAT_HF.value
-url = "https://api.deepinfra.com/v1/inference/meta-llama/Llama-2-70b-chat-hf"
-
-LlamaTwo70B = create_deep_infra_model(
-    model_name=model_name, url=url, model_class_name="LlamaTwo70B"
-)
-
-if __name__ == "__main__":
-    model = LlamaTwo70B(use_cache=False)
-    from edsl.questions import QuestionMultipleChoice
-
-    q = QuestionMultipleChoice(
-        question_text="Are pickled pigs feet a popular breakfast food in the US?",
-        question_options=["Yes", "No", "Unsure"],
-        question_name="bkfast_question",
-    )
-    results = q.by(model).run()
-    results.select("answer.*", "model.model").print()

edsl/language_models/model_interfaces/Mixtral8x7B.py

@@ -1,24 +0,0 @@
-from edsl.enums import LanguageModelType
-from edsl.language_models.DeepInfra import create_deep_infra_model
-
-model_name = LanguageModelType.MIXTRAL_8x7B_INSTRUCT.value
-url = "https://api.deepinfra.com/v1/inference/mistralai/Mixtral-8x7B-Instruct-v0.1"
-
-Mixtral8x7B = create_deep_infra_model(
-    model_name=model_name, url=url, model_class_name="Mixtral8x7B"
-)
-
-if __name__ == "__main__":
-    from edsl.questions import QuestionMultipleChoice
-
-    m = Mixtral8x7B()
-    q = QuestionMultipleChoice(
-        question_text="Are pickled pigs feet a popular breakfast food in the US?",
-        question_options=["Yes", "No", "Unsure"],
-        question_name="bkfast_question",
-    )
-    results = q.by(m).run()
-    from rich import print
-
-    print(q)
-    results.select("answer.*", "model.model").print()

edsl/language_models/registry.py

@@ -1,81 +0,0 @@
-import textwrap
-
-DEFAULT_MODEL_CLASS = "edsl.language_models.LanguageModelOpenAIFour"
-
-from edsl.language_models.LanguageModel import RegisterLanguageModelsMeta
-import pkgutil
-import importlib
-import edsl.language_models.model_interfaces as model_interfaces
-
-# Dynamically import all modules in the model_interfaces package
-for loader, module_name, is_pkg in pkgutil.iter_modules(model_interfaces.__path__):
-    full_module_name = f"{model_interfaces.__name__}.{module_name}"
-    if not is_pkg:
-        module = importlib.import_module(full_module_name)
-        globals().update(
-            {
-                name: getattr(module, name)
-                for name in dir(module)
-                if not name.startswith("_")
-            }
-        )
-
-meta_class_registry = RegisterLanguageModelsMeta.get_registered_classes()
-
-# For compatibility with older versions of EDSL
-get_model_class = (
-    lambda model_name: RegisterLanguageModelsMeta.model_names_to_classes().get(
-        model_name
-    )
-)
-
-
-class Meta(type):
-    def __repr__(cls):
-        return textwrap.dedent(
-            f"""\
-        Available models: {cls.available()}
-        
-        To create an instance, you can do: 
-        >>> m = Model('gpt-4-1106-preview', temperature=0.5, ...)
-        
-        To get the default model, you can leave out the model name. 
-        To see the available models, you can do:
-        >>> Model.available()
-        """
-        )
-
-
-class Model(metaclass=Meta):
-    default_model = "gpt-4-1106-preview"
-
-    def __new__(cls, model_name=None, *args, **kwargs):
-        # Map index to the respective subclass
-        get_model_classes = RegisterLanguageModelsMeta.model_names_to_classes()
-
-        if cls.default_model not in get_model_classes:
-            raise ValueError(f"Default model {cls.default_model} not found")
-
-        if model_name is None:
-            model_name = cls.default_model
-            print(f"No model name provided, using default model: {model_name}")
-
-        subclass = get_model_classes.get(model_name, None)
-        if subclass is None:
-            raise ValueError(f"No model registered with name {model_name}")
-
-        # Create an instance of the selected subclass
-        instance = object.__new__(subclass)
-        instance.__init__(*args, **kwargs)
-        return instance
-
-    @classmethod
-    def available(cls):
-        return list(RegisterLanguageModelsMeta.model_names_to_classes().keys())
-
-
-if __name__ == "__main__":
-    available = Model.available()
-    m = Model("gpt-4-1106-preview")
-    results = m.execute_model_call("Hello world")
-    print(results)

edsl/language_models/schemas.py

@@ -1,15 +0,0 @@
-# MODEL PRICES
-model_prices = {
-    "gpt-3.5-turbo": {
-        "prompt_tokens": 0.001 / 1000,
-        "completion_tokens": 0.002 / 1000,
-    },
-    "gpt-4-1106-preview": {
-        "prompt_tokens": 0.01 / 1000,
-        "completion_tokens": 0.03 / 1000,
-    },
-    "llama2-70b-chat": {
-        "prompt_tokens": 0.03 / 1000,
-        "completion_tokens": 0.03 / 1000,
-    },
-}

edsl/language_models/unused/ReplicateBase.py

@@ -1,83 +0,0 @@
-import asyncio
-import aiohttp
-import json
-from typing import Any
-
-from edsl import CONFIG
-
-from edsl.language_models.LanguageModel import LanguageModel
-
-
-def replicate_model_factory(model_name, base_url, api_token):
-    class ReplicateLanguageModelBase(LanguageModel):
-        _model_ = (
-            model_name  # Example model name, replace with actual model name if needed
-        )
-        _parameters_ = {
-            "temperature": 0.1,
-            "topK": 50,
-            "topP": 0.9,
-            "max_new_tokens": 500,
-            "min_new_tokens": -1,
-            "repetition_penalty": 1.15,
-            #       "version": "5fe0a3d7ac2852264a25279d1dfb798acbc4d49711d126646594e212cb821749",
-            "use_cache": True,
-        }
-        _api_token = api_token
-        _base_url = base_url
-
-        async def async_execute_model_call(
-            self, user_prompt: str, system_prompt: str = ""
-        ) -> dict[str, Any]:
-            self.api_token = self._api_token
-            self.headers = {
-                "Authorization": f"Token {self.api_token}",
-                "Content-Type": "application/json",
-            }
-            # combined_prompt = f"{system_prompt} {user_prompt}".strip()
-            # print(f"Prompt: {combined_prompt}")
-            data = {
-                #          "version": self._parameters_["version"],
-                "input": {
-                    "debug": False,
-                    "top_k": self._parameters_["topK"],
-                    "top_p": self._parameters_["topP"],
-                    "prompt": user_prompt,
-                    "system_prompt": system_prompt,
-                    "temperature": self._parameters_["temperature"],
-                    "max_new_tokens": self._parameters_["max_new_tokens"],
-                    "min_new_tokens": self._parameters_["min_new_tokens"],
-                    "prompt_template": "{prompt}",
-                    "repetition_penalty": self._parameters_["repetition_penalty"],
-                },
-            }
-
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    self._base_url, headers=self.headers, data=json.dumps(data)
-                ) as response:
-                    raw_response_text = await response.text()
-                    data = json.loads(raw_response_text)
-                    print(f"This was the data returned by the model:{data}")
-                    prediction_url = data["urls"]["get"]
-
-                while True:
-                    async with session.get(
-                        prediction_url, headers=self.headers
-                    ) as get_response:
-                        if get_response.status != 200:
-                            # Handle non-success status codes appropriately
-                            return None
-
-                        get_data = await get_response.text()
-                        get_data = json.loads(get_data)
-                        if get_data["status"] == "succeeded":
-                            return get_data
-                        await asyncio.sleep(1)
-
-        def parse_response(self, raw_response: dict[str, Any]) -> str:
-            data = "".join(raw_response["output"])
-            print(f"This is what the model returned: {data}")
-            return data
-
-    return ReplicateLanguageModelBase

edsl/prompts/QuestionInstructionsBase.py

@@ -1,6 +0,0 @@
-from edsl.prompts.Prompt import PromptBase
-from edsl.prompts.prompt_config import ComponentTypes
-
-
-class QuestionInstuctionsBase(PromptBase):
-    component_type = ComponentTypes.QUESTION_INSTRUCTIONS

edsl/prompts/library/agent_instructions.py

@@ -1,29 +0,0 @@
-import textwrap
-
-from edsl.prompts.Prompt import PromptBase
-from edsl.prompts.prompt_config import ComponentTypes
-
-from edsl.enums import LanguageModelType
-
-
-class AgentInstruction(PromptBase):
-    model = LanguageModelType.GPT_3_5_Turbo.value
-    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):
-    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,17 +0,0 @@
-import textwrap
-
-from edsl.prompts.Prompt import PromptBase
-from edsl.prompts.prompt_config import ComponentTypes
-
-from edsl.enums import LanguageModelType
-
-
-class AgentPersona(PromptBase):
-    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,26 +0,0 @@
-import textwrap
-
-from edsl.prompts.QuestionInstructionsBase import QuestionInstuctionsBase
-
-
-class Budget(QuestionInstuctionsBase):
-    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).
-        """
-    )