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

edsl/exceptions/__init__.py

@@ -1,48 +1,54 @@
-from .agents import (
-    AgentAttributeLookupCallbackError,
-    AgentCombinationError,
-    AgentLacksLLMError,
-    AgentRespondedWithBadJSONError,
-)
-from .configuration import (
-    InvalidEnvironmentVariableError,
-    MissingEnvironmentVariableError,
-)
-from .data import (
-    DatabaseConnectionError,
-    DatabaseCRUDError,
-    DatabaseIntegrityError,
-)
+# from .agents import (
+#     #    AgentAttributeLookupCallbackError,
+#     AgentCombinationError,
+#     #    AgentLacksLLMError,
+#     #    AgentRespondedWithBadJSONError,
+# )
+# from .configuration import (
+#     InvalidEnvironmentVariableError,
+#     MissingEnvironmentVariableError,
+# )
+# from .data import (
+#     DatabaseConnectionError,
+#     DatabaseCRUDError,
+#     DatabaseIntegrityError,
+# )
 
-from .jobs import JobsRunError, InterviewErrorPriorTaskCanceled, InterviewTimeoutError
+# from .scenarios import (
+#     ScenarioError,
+# )
 
-from .language_models import (
-    LanguageModelResponseNotJSONError,
-    LanguageModelMissingAttributeError,
-    LanguageModelAttributeTypeError,
-    LanguageModelDoNotAddError,
-)
-from .questions import (
-    QuestionAnswerValidationError,
-    QuestionAttributeMissing,
-    QuestionCreationValidationError,
-    QuestionResponseValidationError,
-    QuestionSerializationError,
-    QuestionScenarioRenderError,
-)
-from .results import (
-    ResultsBadMutationstringError,
-    ResultsColumnNotFoundError,
-    ResultsInvalidNameError,
-    ResultsMutateError,
-)
-from .surveys import (
-    SurveyCreationError,
-    SurveyHasNoRulesError,
-    SurveyRuleCannotEvaluateError,
-    SurveyRuleCollectionHasNoRulesAtNodeError,
-    SurveyRuleReferenceInRuleToUnknownQuestionError,
-    SurveyRuleRefersToFutureStateError,
-    SurveyRuleSendsYouBackwardsError,
-    SurveyRuleSkipLogicSyntaxError,
-)
+# from .general import MissingAPIKeyError
+
+# from .jobs import JobsRunError, InterviewErrorPriorTaskCanceled, InterviewTimeoutError
+
+# from .language_models import (
+#     LanguageModelResponseNotJSONError,
+#     LanguageModelMissingAttributeError,
+#     LanguageModelAttributeTypeError,
+#     LanguageModelDoNotAddError,
+# )
+# from .questions import (
+#     QuestionAnswerValidationError,
+#     QuestionAttributeMissing,
+#     QuestionCreationValidationError,
+#     QuestionResponseValidationError,
+#     QuestionSerializationError,
+#     QuestionScenarioRenderError,
+# )
+# from .results import (
+#     ResultsBadMutationstringError,
+#     ResultsColumnNotFoundError,
+#     ResultsInvalidNameError,
+#     ResultsMutateError,
+# )
+# from .surveys import (
+#     SurveyCreationError,
+#     SurveyHasNoRulesError,
+#     SurveyRuleCannotEvaluateError,
+#     SurveyRuleCollectionHasNoRulesAtNodeError,
+#     SurveyRuleReferenceInRuleToUnknownQuestionError,
+#     SurveyRuleRefersToFutureStateError,
+#     SurveyRuleSendsYouBackwardsError,
+#     SurveyRuleSkipLogicSyntaxError,
+# )

edsl/exceptions/agents.py

@@ -1,33 +1,51 @@
-class AgentErrors(Exception):
-    pass
+from edsl.exceptions.BaseException import BaseException
 
 
-class AgentDynamicTraitsFunctionError(AgentErrors):
-    pass
+# from edsl.utilities.utilities import is_notebook
 
+# from IPython.core.error import UsageError
 
-class AgentDirectAnswerFunctionError(AgentErrors):
-    pass
+# class AgentListErrorAlternative(UsageError):
+#     def __init__(self, message):
+#         super().__init__(message)
 
+import sys
+from edsl.utilities.is_notebook import is_notebook
 
-class AgentAttributeLookupCallbackError(AgentErrors):
-    pass
 
+class AgentListError(BaseException):
+    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html#agent-lists"
 
-class AgentCombinationError(AgentErrors):
-    pass
 
+class AgentErrors(BaseException):
+    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html"
 
-class AgentLacksLLMError(AgentErrors):
-    pass
+
+class AgentDynamicTraitsFunctionError(AgentErrors):
+    relevant_doc = (
+        "https://docs.expectedparrot.com/en/latest/agents.html#dynamic-traits-function"
+    )
+    relevant_notebook = "https://docs.expectedparrot.com/en/latest/notebooks/example_agent_dynamic_traits.html"
 
 
-class AgentRespondedWithBadJSONError(AgentErrors):
-    pass
+class AgentDirectAnswerFunctionError(AgentErrors):
+    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html#agent-direct-answering-methods"
+
+
+class AgentCombinationError(AgentErrors):
+    relevant_doc = (
+        "https://docs.expectedparrot.com/en/latest/agents.html#combining-agents"
+    )
 
 
 class AgentNameError(AgentErrors):
-    pass
+    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html#agent-names"
+
+
+class AgentTraitKeyError(AgentErrors):
+    relevant_doc = (
+        "https://docs.expectedparrot.com/en/latest/agents.html#constructing-an-agent"
+    )
 
 
 class FailedTaskException(Exception):

edsl/exceptions/cache.py

@@ -0,0 +1,5 @@
+from edsl.exceptions.BaseException import BaseException
+
+
+class CacheError(BaseException):
+    relevant_doc = "https://docs.expectedparrot.com/en/latest/agents.html#agent-lists"

edsl/exceptions/coop.py

@@ -1,2 +1,10 @@
 class CoopErrors(Exception):
     pass
+
+
+class CoopNoUUIDError(CoopErrors):
+    pass
+
+
+class CoopServerResponseError(CoopErrors):
+    pass

edsl/exceptions/general.py

@@ -0,0 +1,34 @@
+import re
+from textwrap import dedent
+
+
+class GeneralErrors(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message
+
+    def __str__(self):
+        return self.make_urls_clickable(self.message)
+
+    @staticmethod
+    def make_urls_clickable(text):
+        url_pattern = r"https?://[^\s]+"
+        urls = re.findall(url_pattern, text)
+        for url in urls:
+            clickable_url = f"\033]8;;{url}\007{url}\033]8;;\007"
+            text = text.replace(url, clickable_url)
+        return text
+
+
+class MissingAPIKeyError(GeneralErrors):
+    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/exceptions/inference_services.py

@@ -0,0 +1,5 @@
+from edsl.exceptions.BaseException import BaseException
+
+
+class InferenceServiceError(BaseException):
+    relevant_doc = "https://docs.expectedparrot.com/"

edsl/exceptions/jobs.py

@@ -1,3 +1,6 @@
+from textwrap import dedent
+
+
 class JobsErrors(Exception):
     pass
 
@@ -6,6 +9,18 @@ class JobsRunError(JobsErrors):
     pass
 
 
+class MissingRemoteInferenceError(JobsErrors):
+    def __init__(self):
+        message = dedent(
+            """\\
+                        You are trying to run the job remotely, but you have not set the EXPECTED_PARROT_INFERENCE_URL environment variable.
+                        This remote running service is not quite ready yet! 
+                        But please see https://docs.expectedparrot.com/en/latest/coop.html for what we are working on.
+                        """
+        )
+        super().__init__(message)
+
+
 class InterviewError(Exception):
     pass
 

edsl/exceptions/language_models.py

@@ -1,5 +1,50 @@
+from textwrap import dedent
+from typing import Optional
+
+
 class LanguageModelExceptions(Exception):
-    pass
+    explanation = (
+        "This is the base class for all exceptions in the LanguageModel class."
+    )
+
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message
+
+
+class LanguageModelNoResponseError(LanguageModelExceptions):
+    explanation = (
+        """This happens when the LLM API cannot be reached and/or does not respond."""
+    )
+
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class LanguageModelBadResponseError(LanguageModelExceptions):
+    explanation = """This happens when the LLM API can be reached and responds, does not return a usable answer."""
+
+    def __init__(self, message, response_json: Optional[dict] = None):
+        super().__init__(message)
+        self.response_json = response_json
+
+
+class LanguageModelNotFound(LanguageModelExceptions):
+    def __init__(self, model_name):
+        msg = dedent(
+            f"""\
+            Model {model_name} not found.
+            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()
+
+            See https://docs.expectedparrot.com/en/latest/language_models.html#available-models for more details.
+            """
+        )
+        super().__init__(msg)
 
 
 class LanguageModelResponseNotJSONError(LanguageModelExceptions):

edsl/exceptions/questions.py

@@ -1,16 +1,91 @@
+from typing import Any, SupportsIndex
+import json
+from pydantic import ValidationError
+
+
 class QuestionErrors(Exception):
-    pass
+    """
+    Base exception class for question-related errors.
+    """
 
+    def __init__(self, message="An error occurred with the question"):
+        self.message = message
+        super().__init__(self.message)
 
-class QuestionCreationValidationError(QuestionErrors):
-    pass
 
+class QuestionAnswerValidationError(QuestionErrors):
+    documentation = "https://docs.expectedparrot.com/en/latest/exceptions.html"
+
+    explanation = """This when the answer coming from the Language Model does not conform to the expectation for that question type.
+    For example, if the question is a multiple choice question, the answer should be drawn from the list of options provided.
+    """
+
+    def __init__(
+        self,
+        message="Invalid answer.",
+        pydantic_error: ValidationError = None,
+        data: dict = None,
+        model=None,
+    ):
+        self.message = message
+        self.pydantic_error = pydantic_error
+        self.data = data
+        self.model = model
+        super().__init__(self.message)
+
+    def __str__(self):
+        if isinstance(self.message, ValidationError):
+            # If it's a ValidationError, just return the core error message
+            return str(self.message)
+        elif hasattr(self.message, "errors"):
+            # Handle the case where it's already been converted to a string but has errors
+            error_list = self.message.errors()
+            if error_list:
+                return str(error_list[0].get("msg", "Unknown error"))
+        return str(self.message)
+
+    # def __str__(self):
+    #     return f"""{repr(self)}
+    #     Data being validated: {self.data}
+    #     Pydnantic Model: {self.model}.
+    #     Reported error: {self.message}."""
+
+    def to_html_dict(self):
+        return {
+            "error_type": ("Name of the exception", "p", "/p", self.__class__.__name__),
+            "explaination": ("Explanation", "p", "/p", self.explanation),
+            "edsl answer": (
+                "What model returned",
+                "pre",
+                "/pre",
+                json.dumps(self.data, indent=2),
+            ),
+            "validating_model": (
+                "Pydantic model for answers",
+                "pre",
+                "/pre",
+                json.dumps(self.model.model_json_schema(), indent=2),
+            ),
+            "error_message": (
+                "Error message Pydantic returned",
+                "p",
+                "/p",
+                self.message,
+            ),
+            "documentation_url": (
+                "URL to EDSL docs",
+                f"a href='{self.documentation}'",
+                "/a",
+                self.documentation,
+            ),
+        }
 
-class QuestionResponseValidationError(QuestionErrors):
+
+class QuestionCreationValidationError(QuestionErrors):
     pass
 
 
-class QuestionAnswerValidationError(QuestionErrors):
+class QuestionResponseValidationError(QuestionErrors):
     pass
 
 

edsl/exceptions/results.py

@@ -1,18 +1,29 @@
-class ResultsErrors(Exception):
+from edsl.exceptions.BaseException import BaseException
+
+
+class ResultsError(BaseException):
+    relevant_docs = "https://docs.expectedparrot.com/en/latest/results.html"
+
+
+class ResultsDeserializationError(ResultsError):
+    pass
+
+
+class ResultsBadMutationstringError(ResultsError):
     pass
 
 
-class ResultsBadMutationstringError(ResultsErrors):
+class ResultsColumnNotFoundError(ResultsError):
     pass
 
 
-class ResultsColumnNotFoundError(ResultsErrors):
+class ResultsInvalidNameError(ResultsError):
     pass
 
 
-class ResultsInvalidNameError(ResultsErrors):
+class ResultsMutateError(ResultsError):
     pass
 
 
-class ResultsMutateError(ResultsErrors):
+class ResultsFilterError(ResultsError):
     pass

edsl/exceptions/scenarios.py

@@ -0,0 +1,29 @@
+import re
+import textwrap
+
+# from IPython.core.error import UsageError
+
+
+class AgentListError(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class ScenarioError(Exception):
+    documentation = "https://docs.expectedparrot.com/en/latest/scenarios.html#module-edsl.scenarios.Scenario"
+
+    def __init__(self, message: str):
+        self.message = message + "\n" + "Documentation: " + self.documentation
+        super().__init__(self.message)
+
+    def __str__(self):
+        return self.make_urls_clickable(self.message)
+
+    @staticmethod
+    def make_urls_clickable(text):
+        url_pattern = r"https?://[^\s]+"
+        urls = re.findall(url_pattern, text)
+        for url in urls:
+            clickable_url = f"\033]8;;{url}\007{url}\033]8;;\007"
+            text = text.replace(url, clickable_url)
+        return text

edsl/exceptions/surveys.py

@@ -1,34 +1,37 @@
-class SurveyErrors(Exception):
-    pass
+from edsl.exceptions.BaseException import BaseException
+
+
+class SurveyError(BaseException):
+    relevant_doc = "https://docs.expectedparrot.com/en/latest/surveys.html"
 
 
-class SurveyCreationError(SurveyErrors):
+class SurveyCreationError(SurveyError):
     pass
 
 
-class SurveyHasNoRulesError(SurveyErrors):
+class SurveyHasNoRulesError(SurveyError):
     pass
 
 
-class SurveyRuleSendsYouBackwardsError(SurveyErrors):
+class SurveyRuleSendsYouBackwardsError(SurveyError):
     pass
 
 
-class SurveyRuleSkipLogicSyntaxError(SurveyErrors):
+class SurveyRuleSkipLogicSyntaxError(SurveyError):
     pass
 
 
-class SurveyRuleReferenceInRuleToUnknownQuestionError(SurveyErrors):
+class SurveyRuleReferenceInRuleToUnknownQuestionError(SurveyError):
     pass
 
 
-class SurveyRuleRefersToFutureStateError(SurveyErrors):
+class SurveyRuleRefersToFutureStateError(SurveyError):
     pass
 
 
-class SurveyRuleCollectionHasNoRulesAtNodeError(SurveyErrors):
+class SurveyRuleCollectionHasNoRulesAtNodeError(SurveyError):
     pass
 
 
-class SurveyRuleCannotEvaluateError(SurveyErrors):
+class SurveyRuleCannotEvaluateError(SurveyError):
     pass

edsl/inference_services/AnthropicService.py

@@ -0,0 +1,106 @@
+import os
+from typing import Any, Optional, List
+import re
+from anthropic import AsyncAnthropic
+from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.language_models.LanguageModel import LanguageModel
+
+
+class AnthropicService(InferenceServiceABC):
+    """Anthropic service class."""
+
+    _inference_service_ = "anthropic"
+    _env_key_name_ = "ANTHROPIC_API_KEY"
+    key_sequence = ["content", 0, "text"]
+    usage_sequence = ["usage"]
+    input_token_name = "input_tokens"
+    output_token_name = "output_tokens"
+    model_exclude_list = []
+
+    @classmethod
+    def get_model_list(cls, api_key: str = None):
+
+        import requests
+
+        if api_key is None:
+            api_key = os.environ.get("ANTHROPIC_API_KEY")
+        headers = {"x-api-key": api_key, "anthropic-version": "2023-06-01"}
+        response = requests.get("https://api.anthropic.com/v1/models", headers=headers)
+        model_names = [m["id"] for m in response.json()["data"]]
+        return model_names
+
+    @classmethod
+    def available(cls):
+        return cls.get_model_list()
+
+    @classmethod
+    def create_model(
+        cls, model_name: str = "claude-3-opus-20240229", 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 OpenAI models
+            """
+
+            key_sequence = cls.key_sequence
+            usage_sequence = cls.usage_sequence
+            input_token_name = cls.input_token_name
+            output_token_name = cls.output_token_name
+
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+            _parameters_ = {
+                "temperature": 0.5,
+                "max_tokens": 1000,
+                "top_p": 1,
+                "frequency_penalty": 0,
+                "presence_penalty": 0,
+                "logprobs": False,
+                "top_logprobs": 3,
+            }
+
+            async def async_execute_model_call(
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["Files"]] = None,
+            ) -> dict[str, Any]:
+                """Calls the Anthropic API and returns the API response."""
+
+                messages = [
+                    {
+                        "role": "user",
+                        "content": [{"type": "text", "text": user_prompt}],
+                    }
+                ]
+                if files_list:
+                    for file_entry in files_list:
+                        encoded_image = file_entry.base64_string
+                        messages[0]["content"].append(
+                            {
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": file_entry.mime_type,
+                                    "data": encoded_image,
+                                },
+                            }
+                        )
+                # breakpoint()
+                client = AsyncAnthropic(api_key=self.api_token)
+
+                response = await client.messages.create(
+                    model=model_name,
+                    max_tokens=self.max_tokens,
+                    temperature=self.temperature,
+                    system=system_prompt,  # note that the Anthropic API uses "system" parameter rather than put it in the message
+                    messages=messages,
+                )
+                return response.model_dump()
+
+        LLM.__name__ = model_class_name
+
+        return LLM