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

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,22 @@
-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
+
+
+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,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,
-            }
-
-            _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"]  # ["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

edsl/inference_services/AwsBedrock.py

@@ -1,120 +1,120 @@
-import os
-from typing import Any, List, Optional
-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
-    )
-    key_sequence = ["output", "message", "content", 0, "text"]
-    input_token_name = "inputTokens"
-    output_token_name = "outputTokens"
-    usage_sequence = ["usage"]
-    model_exclude_list = [
-        "ai21.j2-grande-instruct",
-        "ai21.j2-jumbo-instruct",
-        "ai21.j2-mid",
-        "ai21.j2-mid-v1",
-        "ai21.j2-ultra",
-        "ai21.j2-ultra-v1",
-    ]
-    _models_list_cache: List[str] = []
-
-    @classmethod
-    def available(cls):
-        """Fetch available models from AWS Bedrock."""
-
-        region = os.getenv("AWS_REGION", "us-east-1")
-
-        if not cls._models_list_cache:
-            client = boto3.client("bedrock", region_name=region)
-            all_models_ids = [
-                x["modelId"] for x in client.list_foundation_models()["modelSummaries"]
-            ]
-        else:
-            all_models_ids = cls._models_list_cache
-
-        return [m for m in all_models_ids if m not in cls.model_exclude_list]
-
-    @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.
-            """
-
-            key_sequence = cls.key_sequence
-            usage_sequence = cls.usage_sequence
-            _inference_service_ = cls._inference_service_
-            _model_ = model_name
-            _parameters_ = {
-                "temperature": 0.5,
-                "max_tokens": 512,
-                "top_p": 0.9,
-            }
-            input_token_name = cls.input_token_name
-            output_token_name = cls.output_token_name
-            _rpm = cls.get_rpm(cls)
-            _tpm = cls.get_tpm(cls)
-
-            async def async_execute_model_call(
-                self,
-                user_prompt: str,
-                system_prompt: str = "",
-                files_list: Optional[List["FileStore"]] = None,
-            ) -> 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.
-
-                region = os.getenv("AWS_REGION", "us-east-1")
-                client = boto3.client("bedrock-runtime", region_name=region)
-
-                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)}
-
-        LLM.__name__ = model_class_name
-
-        return LLM
+import os
+from typing import Any, List, Optional
+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
+    )
+    key_sequence = ["output", "message", "content", 0, "text"]
+    input_token_name = "inputTokens"
+    output_token_name = "outputTokens"
+    usage_sequence = ["usage"]
+    model_exclude_list = [
+        "ai21.j2-grande-instruct",
+        "ai21.j2-jumbo-instruct",
+        "ai21.j2-mid",
+        "ai21.j2-mid-v1",
+        "ai21.j2-ultra",
+        "ai21.j2-ultra-v1",
+    ]
+    _models_list_cache: List[str] = []
+
+    @classmethod
+    def available(cls):
+        """Fetch available models from AWS Bedrock."""
+
+        region = os.getenv("AWS_REGION", "us-east-1")
+
+        if not cls._models_list_cache:
+            client = boto3.client("bedrock", region_name=region)
+            all_models_ids = [
+                x["modelId"] for x in client.list_foundation_models()["modelSummaries"]
+            ]
+        else:
+            all_models_ids = cls._models_list_cache
+
+        return [m for m in all_models_ids if m not in cls.model_exclude_list]
+
+    @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.
+            """
+
+            key_sequence = cls.key_sequence
+            usage_sequence = cls.usage_sequence
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+            _parameters_ = {
+                "temperature": 0.5,
+                "max_tokens": 512,
+                "top_p": 0.9,
+            }
+            input_token_name = cls.input_token_name
+            output_token_name = cls.output_token_name
+            _rpm = cls.get_rpm(cls)
+            _tpm = cls.get_tpm(cls)
+
+            async def async_execute_model_call(
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["FileStore"]] = None,
+            ) -> 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.
+
+                region = os.getenv("AWS_REGION", "us-east-1")
+                client = boto3.client("bedrock-runtime", region_name=region)
+
+                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)}
+
+        LLM.__name__ = model_class_name
+
+        return LLM