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

edsl/__version__.py

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

edsl/agents/Invigilator.py

@@ -19,7 +19,7 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
 
     async def async_answer_question(self) -> AgentResponseDict:
         """Answer a question using the AI model.
-        
+
         >>> i = InvigilatorAI.example()
         >>> i.answer_question()
         {'message': '{"answer": "SPAM!"}'}
@@ -34,7 +34,7 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
             "raw_model_response": raw_response["raw_model_response"],
         }
         response = self._format_raw_response(**data)
-        #breakpoint()
+        # breakpoint()
         return AgentResponseDict(**response)
 
     async def async_get_response(
@@ -44,8 +44,7 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
         iteration: int = 0,
         encoded_image=None,
     ) -> dict:
-        """Call the LLM and gets a response. Used in the `answer_question` method.        
-        """
+        """Call the LLM and gets a response. Used in the `answer_question` method."""
         try:
             params = {
                 "user_prompt": user_prompt.text,

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

@@ -69,6 +69,15 @@ CONFIG_MAP = {
     #     "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).",
 }
 
 
@@ -113,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/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

@@ -60,6 +60,9 @@ class InferenceServiceType(EnumWithChecks):
     TEST = "test"
     ANTHROPIC = "anthropic"
     GROQ = "groq"
+    AZURE = "azure"
+    OLLAMA = "ollama"
+
 
 service_to_api_keyname = {
     InferenceServiceType.BEDROCK.value: "TBD",
@@ -70,6 +73,7 @@ service_to_api_keyname = {
     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,16 +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(OpenAIService):
     """DeepInfra service class."""
 
     _inference_service_ = "deep_infra"
     _env_key_name_ = "DEEP_INFRA_API_KEY"
-    _base_url_ = "https://api.deepinfra.com/v1/openai" 
+    _base_url_ = "https://api.deepinfra.com/v1/openai"
     _models_list_cache: List[str] = []
-

edsl/inference_services/GroqService.py

@@ -10,10 +10,9 @@ class GroqService(OpenAIService):
     _inference_service_ = "groq"
     _env_key_name_ = "GROQ_API_KEY"
 
-    _sync_client_ =  groq.Groq
-    _async_client_ = groq.AsyncGroq 
+    _sync_client_ = groq.Groq
+    _async_client_ = groq.AsyncGroq
 
-    #_base_url_ = "https://api.deepinfra.com/v1/openai" 
+    # _base_url_ = "https://api.deepinfra.com/v1/openai"
     _base_url_ = None
     _models_list_cache: List[str] = []
-

edsl/inference_services/InferenceServicesCollection.py

@@ -15,18 +15,19 @@ class InferenceServicesCollection:
         cls.added_models[service_name].append(model_name)
 
     @staticmethod
-    def _get_service_available(service) -> list[str]:
+    def _get_service_available(service, warn: bool = False) -> list[str]:
         from_api = True
         try:
             service_models = service.available()
         except Exception as e:
-            warnings.warn(
-                f"""Error getting models for {service._inference_service_}. 
-                Check that you have properly stored your Expected Parrot API key and activated remote inference, or stored your own API keys for the language models that you want to use.
-                See https://docs.expectedparrot.com/en/latest/api_keys.html for instructions on storing API keys.
-                Relying on cache.""",
-                UserWarning,
-            )
+            if warn:
+                warnings.warn(
+                    f"""Error getting models for {service._inference_service_}. 
+                    Check that you have properly stored your Expected Parrot API key and activated remote inference, or stored your own API keys for the language models that you want to use.
+                    See https://docs.expectedparrot.com/en/latest/api_keys.html for instructions on storing API keys.
+                    Relying on cache.""",
+                    UserWarning,
+                )
             from edsl.inference_services.models_available_cache import models_available
 
             service_models = models_available.get(service._inference_service_, [])
@@ -60,4 +61,8 @@ class InferenceServicesCollection:
                 if service_name is None or service_name == service._inference_service_:
                     return service.create_model(model_name)
 
+        # if model_name == "test":
+        #     from edsl.language_models import LanguageModel
+        #     return LanguageModel(test = True)
+
         raise Exception(f"Model {model_name} not found in any of the services")

edsl/inference_services/OllamaService.py

@@ -0,0 +1,18 @@
+import aiohttp
+import json
+import requests
+from typing import Any, List
+
+# from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.language_models import LanguageModel
+
+from edsl.inference_services.OpenAIService import OpenAIService
+
+
+class OllamaService(OpenAIService):
+    """DeepInfra service class."""
+
+    _inference_service_ = "ollama"
+    _env_key_name_ = "DEEP_INFRA_API_KEY"
+    _base_url_ = "http://localhost:11434/v1"
+    _models_list_cache: List[str] = []