edsl 0.1.31.dev3__py3-none-any.whl → 0.1.32__py3-none-any.whl

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.31.dev3"
+__version__ = "0.1.32"

edsl/agents/Invigilator.py

@@ -18,7 +18,12 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
     """An invigilator that uses an AI model to answer questions."""
 
     async def async_answer_question(self) -> AgentResponseDict:
-        """Answer a question using the AI model."""
+        """Answer a question using the AI model.
+
+        >>> i = InvigilatorAI.example()
+        >>> i.answer_question()
+        {'message': '{"answer": "SPAM!"}'}
+        """
         params = self.get_prompts() | {"iteration": self.iteration}
         raw_response = await self.async_get_response(**params)
         data = {
@@ -29,6 +34,7 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
             "raw_model_response": raw_response["raw_model_response"],
         }
         response = self._format_raw_response(**data)
+        # breakpoint()
         return AgentResponseDict(**response)
 
     async def async_get_response(
@@ -97,7 +103,6 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
         answer = question._translate_answer_code_to_answer(
             response["answer"], combined_dict
         )
-        # breakpoint()
         data = {
             "answer": answer,
             "comment": response.get(

edsl/agents/PromptConstructionMixin.py

@@ -214,6 +214,17 @@ class PromptConstructorMixin:
 
         return self._agent_persona_prompt
 
+    def prior_answers_dict(self) -> dict:
+        d = self.survey.question_names_to_questions()
+        for question, answer in self.current_answers.items():
+            if question in d:
+                d[question].answer = answer
+            else:
+                # adds a comment to the question
+                if (new_question := question.split("_comment")[0]) in d:
+                    d[new_question].comment = answer
+        return d
+
     @property
     def question_instructions_prompt(self) -> Prompt:
         """
@@ -266,29 +277,38 @@ class PromptConstructorMixin:
             question_prompt = self.question.get_instructions(model=self.model.model)
 
             # TODO: Try to populate the answers in the question object if they are available
-            d = self.survey.question_names_to_questions()
-            for question, answer in self.current_answers.items():
-                if question in d:
-                    d[question].answer = answer
-                else:
-                    # adds a comment to the question
-                    if (new_question := question.split("_comment")[0]) in d:
-                        d[new_question].comment = answer
+            # d = self.survey.question_names_to_questions()
+            # for question, answer in self.current_answers.items():
+            #     if question in d:
+            #         d[question].answer = answer
+            #     else:
+            #         # adds a comment to the question
+            #         if (new_question := question.split("_comment")[0]) in d:
+            #             d[new_question].comment = answer
 
             question_data = self.question.data.copy()
 
-            # check to see if the questio_options is actuall a string
+            # check to see if the question_options is actually a string
+            # This is used when the user is using the question_options as a variable from a sceario
             if "question_options" in question_data:
                 if isinstance(self.question.data["question_options"], str):
                     from jinja2 import Environment, meta
+
                     env = Environment()
-                    parsed_content = env.parse(self.question.data['question_options'])
-                    question_option_key = list(meta.find_undeclared_variables(parsed_content))[0]
-                    question_data["question_options"] = self.scenario.get(question_option_key)   
+                    parsed_content = env.parse(self.question.data["question_options"])
+                    question_option_key = list(
+                        meta.find_undeclared_variables(parsed_content)
+                    )[0]
+                    question_data["question_options"] = self.scenario.get(
+                        question_option_key
+                    )
 
-            #breakpoint()        
+            # breakpoint()
             rendered_instructions = question_prompt.render(
-                question_data | self.scenario | d | {"agent": self.agent}
+                question_data
+                | self.scenario
+                | self.prior_answers_dict()
+                | {"agent": self.agent}
             )
 
             undefined_template_variables = (
@@ -321,7 +341,7 @@ class PromptConstructorMixin:
             if self.memory_plan is not None:
                 memory_prompt += self.create_memory_prompt(
                     self.question.question_name
-                ).render(self.scenario)
+                ).render(self.scenario | self.prior_answers_dict())
             self._prior_question_memory_prompt = memory_prompt
         return self._prior_question_memory_prompt
 

edsl/config.py

@@ -65,6 +65,19 @@ CONFIG_MAP = {
     #     "default": None,
     #     "info": "This env var holds your Anthropic API key (https://www.anthropic.com/).",
     # },
+    # "GROQ_API_KEY": {
+    #     "default": None,
+    #     "info": "This env var holds your GROQ API key (https://console.groq.com/login).",
+    # },
+    # "AWS_ACCESS_KEY_ID" :
+    #     "default": None,
+    #     "info": "This env var holds your AWS access key ID.",
+    # "AWS_SECRET_ACCESS_KEY:
+    #     "default": None,
+    #     "info": "This env var holds your AWS secret access key.",
+    # "AZURE_ENDPOINT_URL_AND_KEY":
+    #     "default": None,
+    #     "info": "This env var holds your Azure endpoint URL and key (URL:key). You can have several comma-separated URL-key pairs (URL1:key1,URL2:key2).",
 }
 
 
@@ -109,8 +122,9 @@ class Config:
         """
         # for each env var in the CONFIG_MAP
         for env_var, config in CONFIG_MAP.items():
+            # we've set it already in _set_run_mode
             if env_var == "EDSL_RUN_MODE":
-                continue  # we've set it already in _set_run_mode
+                continue
             value = os.getenv(env_var)
             default_value = config.get("default")
             # if the env var is set, set it as a CONFIG attribute

edsl/conjure/Conjure.py

@@ -35,6 +35,12 @@ class Conjure:
         # The __init__ method in Conjure won't be called because __new__ returns a different class instance.
         pass
 
+    @classmethod
+    def example(cls):
+        from edsl.conjure.InputData import InputDataABC
+
+        return InputDataABC.example()
+
 
 if __name__ == "__main__":
     pass

edsl/coop/coop.py

@@ -465,6 +465,7 @@ class Coop:
         description: Optional[str] = None,
         status: RemoteJobStatus = "queued",
         visibility: Optional[VisibilityType] = "unlisted",
+        iterations: Optional[int] = 1,
     ) -> dict:
         """
         Send a remote inference job to the server.
@@ -473,6 +474,7 @@ class Coop:
         :param optional description: A description for this entry in the remote cache.
         :param status: The status of the job. Should be 'queued', unless you are debugging.
         :param visibility: The visibility of the cache entry.
+        :param iterations: The number of times to run each interview.
 
         >>> job = Jobs.example()
         >>> coop.remote_inference_create(job=job, description="My job")
@@ -488,6 +490,7 @@ class Coop:
                 ),
                 "description": description,
                 "status": status,
+                "iterations": iterations,
                 "visibility": visibility,
                 "version": self._edsl_version,
             },
@@ -498,6 +501,7 @@ class Coop:
             "uuid": response_json.get("jobs_uuid"),
             "description": response_json.get("description"),
             "status": response_json.get("status"),
+            "iterations": response_json.get("iterations"),
             "visibility": response_json.get("visibility"),
             "version": self._edsl_version,
         }

edsl/data/CacheHandler.py

@@ -41,7 +41,7 @@ class CacheHandler:
         old_data = self.from_old_sqlite_cache()
         self.cache.add_from_dict(old_data)
 
-    def create_cache_directory(self) -> None:
+    def create_cache_directory(self, notify=False) -> None:
         """
         Create the cache directory if one is required and it does not exist.
         """
@@ -49,9 +49,8 @@ class CacheHandler:
         dir_path = os.path.dirname(path)
         if dir_path and not os.path.exists(dir_path):
             os.makedirs(dir_path)
-            import warnings
-
-            warnings.warn(f"Created cache directory: {dir_path}")
+            if notify:
+                print(f"Created cache directory: {dir_path}")
 
     def gen_cache(self) -> Cache:
         """

edsl/enums.py

@@ -59,6 +59,9 @@ class InferenceServiceType(EnumWithChecks):
     GOOGLE = "google"
     TEST = "test"
     ANTHROPIC = "anthropic"
+    GROQ = "groq"
+    AZURE = "azure"
+    OLLAMA = "ollama"
 
 
 service_to_api_keyname = {
@@ -69,6 +72,8 @@ service_to_api_keyname = {
     InferenceServiceType.GOOGLE.value: "GOOGLE_API_KEY",
     InferenceServiceType.TEST.value: "TBD",
     InferenceServiceType.ANTHROPIC.value: "ANTHROPIC_API_KEY",
+    InferenceServiceType.GROQ.value: "GROQ_API_KEY",
+    InferenceServiceType.BEDROCK.value: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
 }
 
 

edsl/exceptions/general.py

@@ -21,12 +21,14 @@ class GeneralErrors(Exception):
 
 
 class MissingAPIKeyError(GeneralErrors):
-    def __init__(self, model_name, inference_service):
-        full_message = dedent(
-            f"""
-        An API Key for model `{model_name}` is missing from the .env file.
-        This key is associated with the inference service `{inference_service}`.
-        Please see https://docs.expectedparrot.com/en/latest/api_keys.html for more information.
-        """
-        )
+    def __init__(self, full_message=None, model_name=None, inference_service=None):
+        if model_name and inference_service:
+            full_message = dedent(
+                f"""
+            An API Key for model `{model_name}` is missing from the .env file.
+            This key is associated with the inference service `{inference_service}`.
+            Please see https://docs.expectedparrot.com/en/latest/api_keys.html for more information.
+            """
+            )
+
         super().__init__(full_message)

edsl/inference_services/AwsBedrock.py

@@ -0,0 +1,110 @@
+import os
+from typing import Any
+import re
+import boto3
+from botocore.exceptions import ClientError
+from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.language_models.LanguageModel import LanguageModel
+import json
+from edsl.utilities.utilities import fix_partial_correct_response
+
+
+class AwsBedrockService(InferenceServiceABC):
+    """AWS Bedrock service class."""
+
+    _inference_service_ = "bedrock"
+    _env_key_name_ = (
+        "AWS_ACCESS_KEY_ID"  # or any other environment key for AWS credentials
+    )
+
+    @classmethod
+    def available(cls):
+        """Fetch available models from AWS Bedrock."""
+        if not cls._models_list_cache:
+            client = boto3.client("bedrock", region_name="us-west-2")
+            all_models_ids = [
+                x["modelId"] for x in client.list_foundation_models()["modelSummaries"]
+            ]
+        else:
+            all_models_ids = cls._models_list_cache
+
+        return all_models_ids
+
+    @classmethod
+    def create_model(
+        cls, model_name: str = "amazon.titan-tg1-large", model_class_name=None
+    ) -> LanguageModel:
+        if model_class_name is None:
+            model_class_name = cls.to_class_name(model_name)
+
+        class LLM(LanguageModel):
+            """
+            Child class of LanguageModel for interacting with AWS Bedrock models.
+            """
+
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+            _parameters_ = {
+                "temperature": 0.5,
+                "max_tokens": 512,
+                "top_p": 0.9,
+            }
+
+            async def async_execute_model_call(
+                self, user_prompt: str, system_prompt: str = ""
+            ) -> dict[str, Any]:
+                """Calls the AWS Bedrock API and returns the API response."""
+
+                api_token = (
+                    self.api_token
+                )  # call to check the if env variables are set.
+
+                client = boto3.client("bedrock-runtime", region_name="us-west-2")
+
+                conversation = [
+                    {
+                        "role": "user",
+                        "content": [{"text": user_prompt}],
+                    }
+                ]
+                system = [
+                    {
+                        "text": system_prompt,
+                    }
+                ]
+                try:
+                    response = client.converse(
+                        modelId=self._model_,
+                        messages=conversation,
+                        inferenceConfig={
+                            "maxTokens": self.max_tokens,
+                            "temperature": self.temperature,
+                            "topP": self.top_p,
+                        },
+                        # system=system,
+                        additionalModelRequestFields={},
+                    )
+                    return response
+                except (ClientError, Exception) as e:
+                    print(e)
+                    return {"error": str(e)}
+
+            @staticmethod
+            def parse_response(raw_response: dict[str, Any]) -> str:
+                """Parses the API response and returns the response text."""
+                if "output" in raw_response and "message" in raw_response["output"]:
+                    response = raw_response["output"]["message"]["content"][0]["text"]
+                    pattern = r"^```json(?:\\n|\n)(.+?)(?:\\n|\n)```$"
+                    match = re.match(pattern, response, re.DOTALL)
+                    if match:
+                        return match.group(1)
+                    else:
+                        out = fix_partial_correct_response(response)
+                        if "error" not in out:
+                            response = out["extracted_json"]
+                        return response
+                return "Error parsing response"
+
+        LLM.__name__ = model_class_name
+
+        return LLM

edsl/inference_services/AzureAI.py

@@ -0,0 +1,197 @@
+import os
+from typing import Any
+import re
+from openai import AsyncAzureOpenAI
+from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.language_models.LanguageModel import LanguageModel
+
+from azure.ai.inference.aio import ChatCompletionsClient
+from azure.core.credentials import AzureKeyCredential
+from azure.ai.inference.models import SystemMessage, UserMessage
+import asyncio
+import json
+from edsl.utilities.utilities import fix_partial_correct_response
+
+
+def json_handle_none(value: Any) -> Any:
+    """
+    Handle None values during JSON serialization.
+    - Return "null" if the value is None. Otherwise, don't return anything.
+    """
+    if value is None:
+        return "null"
+
+
+class AzureAIService(InferenceServiceABC):
+    """Azure AI service class."""
+
+    _inference_service_ = "azure"
+    _env_key_name_ = (
+        "AZURE_ENDPOINT_URL_AND_KEY"  # Environment variable for Azure API key
+    )
+    _model_id_to_endpoint_and_key = {}
+
+    @classmethod
+    def available(cls):
+        out = []
+        azure_endpoints = os.getenv("AZURE_ENDPOINT_URL_AND_KEY", None)
+        if not azure_endpoints:
+            raise EnvironmentError(f"AZURE_ENDPOINT_URL_AND_KEY is not defined")
+        azure_endpoints = azure_endpoints.split(",")
+        for data in azure_endpoints:
+            try:
+                # data has this format for non openai models https://model_id.azure_endpoint:azure_key
+                _, endpoint, azure_endpoint_key = data.split(":")
+                if "openai" not in endpoint:
+                    model_id = endpoint.split(".")[0].replace("/", "")
+                    out.append(model_id)
+                    cls._model_id_to_endpoint_and_key[model_id] = {
+                        "endpoint": f"https:{endpoint}",
+                        "azure_endpoint_key": azure_endpoint_key,
+                    }
+                else:
+                    # data has this format for openai models ,https://azure_project_id.openai.azure.com/openai/deployments/gpt-4o-mini/chat/completions?api-version=2023-03-15-preview:azure_key
+                    if "/deployments/" in endpoint:
+                        start_idx = endpoint.index("/deployments/") + len(
+                            "/deployments/"
+                        )
+                        end_idx = (
+                            endpoint.index("/", start_idx)
+                            if "/" in endpoint[start_idx:]
+                            else len(endpoint)
+                        )
+                        model_id = endpoint[start_idx:end_idx]
+                        api_version_value = None
+                        if "api-version=" in endpoint:
+                            start_idx = endpoint.index("api-version=") + len(
+                                "api-version="
+                            )
+                            end_idx = (
+                                endpoint.index("&", start_idx)
+                                if "&" in endpoint[start_idx:]
+                                else len(endpoint)
+                            )
+                            api_version_value = endpoint[start_idx:end_idx]
+
+                        cls._model_id_to_endpoint_and_key[f"azure:{model_id}"] = {
+                            "endpoint": f"https:{endpoint}",
+                            "azure_endpoint_key": azure_endpoint_key,
+                            "api_version": api_version_value,
+                        }
+                        out.append(f"azure:{model_id}")
+
+            except Exception as e:
+                raise e
+        return out
+
+    @classmethod
+    def create_model(
+        cls, model_name: str = "azureai", model_class_name=None
+    ) -> LanguageModel:
+        if model_class_name is None:
+            model_class_name = cls.to_class_name(model_name)
+
+        class LLM(LanguageModel):
+            """
+            Child class of LanguageModel for interacting with Azure OpenAI models.
+            """
+
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+            _parameters_ = {
+                "temperature": 0.5,
+                "max_tokens": 512,
+                "top_p": 0.9,
+            }
+
+            async def async_execute_model_call(
+                self, user_prompt: str, system_prompt: str = ""
+            ) -> dict[str, Any]:
+                """Calls the Azure OpenAI API and returns the API response."""
+
+                try:
+                    api_key = cls._model_id_to_endpoint_and_key[model_name][
+                        "azure_endpoint_key"
+                    ]
+                except:
+                    api_key = None
+
+                if not api_key:
+                    raise EnvironmentError(
+                        f"AZURE_ENDPOINT_URL_AND_KEY doesn't have the endpoint:key pair for your model: {model_name}"
+                    )
+
+                try:
+                    endpoint = cls._model_id_to_endpoint_and_key[model_name]["endpoint"]
+                except:
+                    endpoint = None
+
+                if not endpoint:
+                    raise EnvironmentError(
+                        f"AZURE_ENDPOINT_URL_AND_KEY doesn't have the endpoint:key pair for your model: {model_name}"
+                    )
+
+                if "openai" not in endpoint:
+                    client = ChatCompletionsClient(
+                        endpoint=endpoint,
+                        credential=AzureKeyCredential(api_key),
+                        temperature=self.temperature,
+                        top_p=self.top_p,
+                        max_tokens=self.max_tokens,
+                    )
+                    try:
+                        response = await client.complete(
+                            messages=[
+                                SystemMessage(content=system_prompt),
+                                UserMessage(content=user_prompt),
+                            ],
+                            # model_extras={"safe_mode": True},
+                        )
+                        await client.close()
+                        return response.as_dict()
+                    except Exception as e:
+                        await client.close()
+                        return {"error": str(e)}
+                else:
+                    api_version = cls._model_id_to_endpoint_and_key[model_name][
+                        "api_version"
+                    ]
+                    client = AsyncAzureOpenAI(
+                        azure_endpoint=endpoint,
+                        api_version=api_version,
+                        api_key=api_key,
+                    )
+                    response = await client.chat.completions.create(
+                        model=model_name,
+                        messages=[
+                            {
+                                "role": "user",
+                                "content": user_prompt,  # Your question can go here
+                            },
+                        ],
+                    )
+                    return response.model_dump()
+
+            @staticmethod
+            def parse_response(raw_response: dict[str, Any]) -> str:
+                """Parses the API response and returns the response text."""
+                if (
+                    raw_response
+                    and "choices" in raw_response
+                    and raw_response["choices"]
+                ):
+                    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:
+                        out = fix_partial_correct_response(response)
+                        if "error" not in out:
+                            response = out["extracted_json"]
+                        return response
+                return "Error parsing response"
+
+        LLM.__name__ = model_class_name
+
+        return LLM

edsl/inference_services/DeepInfraService.py

@@ -2,102 +2,17 @@ import aiohttp
 import json
 import requests
 from typing import Any, List
-from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+
+# from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
 from edsl.language_models import LanguageModel
 
+from edsl.inference_services.OpenAIService import OpenAIService
+
 
-class DeepInfraService(InferenceServiceABC):
+class DeepInfraService(OpenAIService):
     """DeepInfra service class."""
 
     _inference_service_ = "deep_infra"
     _env_key_name_ = "DEEP_INFRA_API_KEY"
-
+    _base_url_ = "https://api.deepinfra.com/v1/openai"
     _models_list_cache: List[str] = []
-
-    @classmethod
-    def available(cls):
-        text_models = cls.full_details_available()
-        return [m["model_name"] for m in text_models]
-
-    @classmethod
-    def full_details_available(cls, verbose=False):
-        if not cls._models_list_cache:
-            url = "https://api.deepinfra.com/models/list"
-            response = requests.get(url)
-            if response.status_code == 200:
-                text_generation_models = [
-                    r for r in response.json() if r["type"] == "text-generation"
-                ]
-                cls._models_list_cache = text_generation_models
-
-                from rich import print_json
-                import json
-
-                if verbose:
-                    print_json(json.dumps(text_generation_models))
-                return text_generation_models
-            else:
-                return f"Failed to fetch data: Status code {response.status_code}"
-        else:
-            return cls._models_list_cache
-
-    @classmethod
-    def create_model(cls, model_name: str, model_class_name=None) -> LanguageModel:
-        base_url = "https://api.deepinfra.com/v1/inference/"
-        if model_class_name is None:
-            model_class_name = cls.to_class_name(model_name)
-        url = f"{base_url}{model_name}"
-
-        class LLM(LanguageModel):
-            _inference_service_ = cls._inference_service_
-            _model_ = model_name
-            _parameters_ = {
-                "temperature": 0.7,
-                "top_p": 0.2,
-                "top_k": 0.1,
-                "max_new_tokens": 512,
-                "stopSequences": [],
-            }
-
-            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"bearer {self.api_token}",
-                }
-                # don't mess w/ the newlines
-                data = {
-                    "input": f"""
-                    [INST]<<SYS>>
-                    {system_prompt}
-                    <<SYS>>{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:
-                if "results" not in raw_response:
-                    raise Exception(
-                        f"Deep Infra response does not contain 'results' key: {raw_response}"
-                    )
-                if "generated_text" not in raw_response["results"][0]:
-                    raise Exception(
-                        f"Deep Infra response does not contain 'generate_text' key: {raw_response['results'][0]}"
-                    )
-                return raw_response["results"][0]["generated_text"]
-
-        LLM.__name__ = model_class_name
-
-        return LLM