edsl 0.1.39.dev3__py3-none-any.whl → 0.1.39.dev4__py3-none-any.whl

edsl/exceptions/questions.py

@@ -1,91 +1,109 @@
-from typing import Any, SupportsIndex
-from jinja2 import Template
-import json
-
-
-class QuestionErrors(Exception):
-    """
-    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 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.", data=None, model=None):
-        self.message = message
-        self.data = data
-        self.model = model
-        super().__init__(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 QuestionCreationValidationError(QuestionErrors):
-    pass
-
-
-class QuestionResponseValidationError(QuestionErrors):
-    pass
-
-
-class QuestionAttributeMissing(QuestionErrors):
-    pass
-
-
-class QuestionSerializationError(QuestionErrors):
-    pass
-
-
-class QuestionScenarioRenderError(QuestionErrors):
-    pass
-
-
-class QuestionMissingTypeError(QuestionErrors):
-    pass
-
-
-class QuestionBadTypeError(QuestionErrors):
-    pass
+from typing import Any, SupportsIndex
+import json
+from pydantic import ValidationError
+
+
+class QuestionErrors(Exception):
+    """
+    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 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 QuestionCreationValidationError(QuestionErrors):
+    pass
+
+
+class QuestionResponseValidationError(QuestionErrors):
+    pass
+
+
+class QuestionAttributeMissing(QuestionErrors):
+    pass
+
+
+class QuestionSerializationError(QuestionErrors):
+    pass
+
+
+class QuestionScenarioRenderError(QuestionErrors):
+    pass
+
+
+class QuestionMissingTypeError(QuestionErrors):
+    pass
+
+
+class QuestionBadTypeError(QuestionErrors):
+    pass

edsl/exceptions/results.py

@@ -1,29 +1,29 @@
-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 ResultsColumnNotFoundError(ResultsError):
-    pass
-
-
-class ResultsInvalidNameError(ResultsError):
-    pass
-
-
-class ResultsMutateError(ResultsError):
-    pass
-
-
-class ResultsFilterError(ResultsError):
-    pass
+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 ResultsColumnNotFoundError(ResultsError):
+    pass
+
+
+class ResultsInvalidNameError(ResultsError):
+    pass
+
+
+class ResultsMutateError(ResultsError):
+    pass
+
+
+class ResultsFilterError(ResultsError):
+    pass

edsl/exceptions/scenarios.py

@@ -1,22 +1,29 @@
-import re
-import textwrap
-
-
-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
+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,37 +1,37 @@
-from edsl.exceptions.BaseException import BaseException
-
-
-class SurveyError(BaseException):
-    relevant_doc = "https://docs.expectedparrot.com/en/latest/surveys.html"
-
-
-class SurveyCreationError(SurveyError):
-    pass
-
-
-class SurveyHasNoRulesError(SurveyError):
-    pass
-
-
-class SurveyRuleSendsYouBackwardsError(SurveyError):
-    pass
-
-
-class SurveyRuleSkipLogicSyntaxError(SurveyError):
-    pass
-
-
-class SurveyRuleReferenceInRuleToUnknownQuestionError(SurveyError):
-    pass
-
-
-class SurveyRuleRefersToFutureStateError(SurveyError):
-    pass
-
-
-class SurveyRuleCollectionHasNoRulesAtNodeError(SurveyError):
-    pass
-
-
-class SurveyRuleCannotEvaluateError(SurveyError):
-    pass
+from edsl.exceptions.BaseException import BaseException
+
+
+class SurveyError(BaseException):
+    relevant_doc = "https://docs.expectedparrot.com/en/latest/surveys.html"
+
+
+class SurveyCreationError(SurveyError):
+    pass
+
+
+class SurveyHasNoRulesError(SurveyError):
+    pass
+
+
+class SurveyRuleSendsYouBackwardsError(SurveyError):
+    pass
+
+
+class SurveyRuleSkipLogicSyntaxError(SurveyError):
+    pass
+
+
+class SurveyRuleReferenceInRuleToUnknownQuestionError(SurveyError):
+    pass
+
+
+class SurveyRuleRefersToFutureStateError(SurveyError):
+    pass
+
+
+class SurveyRuleCollectionHasNoRulesAtNodeError(SurveyError):
+    pass
+
+
+class SurveyRuleCannotEvaluateError(SurveyError):
+    pass

edsl/inference_services/AnthropicService.py

@@ -1,87 +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"]  # ["content"][0]["text"]
-    usage_sequence = ["usage"]
-    input_token_name = "input_tokens"
-    output_token_name = "output_tokens"
-    model_exclude_list = []
-
-    @classmethod
-    def available(cls):
-        # TODO - replace with an API call
-        return [
-            "claude-3-5-sonnet-20240620",
-            "claude-3-opus-20240229",
-            "claude-3-sonnet-20240229",
-            "claude-3-haiku-20240307",
-        ]
-
-    @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,
-            }
-
-            _tpm = cls.get_tpm(cls)
-            _rpm = cls.get_rpm(cls)
-
-            async def async_execute_model_call(
-                self,
-                user_prompt: str,
-                system_prompt: str = "",
-                files_list: Optional[List["Files"]] = None,
-            ) -> dict[str, Any]:
-                """Calls the OpenAI API and returns the API response."""
-
-                api_key = os.environ.get("ANTHROPIC_API_KEY")
-                client = AsyncAnthropic(api_key=api_key)
-
-                response = await client.messages.create(
-                    model=model_name,
-                    max_tokens=self.max_tokens,
-                    temperature=self.temperature,
-                    system=system_prompt,
-                    messages=[
-                        #                        {"role": "system", "content": system_prompt},
-                        {"role": "user", "content": user_prompt},
-                    ],
-                )
-                return response.model_dump()
-
-        LLM.__name__ = model_class_name
-
-        return LLM
+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