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

edsl/exceptions/questions.py

@@ -1,109 +1,91 @@
-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
+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

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,29 +1,22 @@
-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
+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

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,84 +1,87 @@
-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,
-            }
-
-            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"]  # ["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