edsl 0.1.33__py3-none-any.whl → 0.1.33.dev1__py3-none-any.whl

edsl/language_models/registry.py

@@ -1,11 +1,5 @@
 import textwrap
 from random import random
-from edsl.config import CONFIG
-
-# if "EDSL_DEFAULT_MODEL" not in CONFIG:
-#     default_model = "test"
-# else:
-#     default_model = CONFIG.get("EDSL_DEFAULT_MODEL")
 
 
 def get_model_class(model_name, registry=None):
@@ -33,24 +27,20 @@ class Meta(type):
 
 
 class Model(metaclass=Meta):
-    default_model = CONFIG.get("EDSL_DEFAULT_MODEL")
+    default_model = "gpt-4-1106-preview"
 
-    def __new__(
-        cls, model_name=None, registry=None, service_name=None, *args, **kwargs
-    ):
+    def __new__(cls, model_name=None, registry=None, *args, **kwargs):
         # Map index to the respective subclass
         if model_name is None:
-            model_name = (
-                cls.default_model
-            )  # when model_name is None, use the default model, set in the config file
+            model_name = cls.default_model
         from edsl.inference_services.registry import default
 
         registry = registry or default
 
-        if isinstance(model_name, int):  # can refer to a model by index
+        if isinstance(model_name, int):
             model_name = cls.available(name_only=True)[model_name]
 
-        factory = registry.create_model_factory(model_name, service_name=service_name)
+        factory = registry.create_model_factory(model_name)
         return factory(*args, **kwargs)
 
     @classmethod
@@ -68,18 +58,11 @@ class Model(metaclass=Meta):
         return [r._inference_service_ for r in registry.services]
 
     @classmethod
-    def available(cls, search_term=None, name_only=False, registry=None, service=None):
+    def available(cls, search_term=None, name_only=False, registry=None):
         from edsl.inference_services.registry import default
 
         registry = registry or default
         full_list = registry.available()
-
-        if service is not None:
-            if service not in cls.services(registry=registry):
-                raise ValueError(f"Service {service} not found in available services.")
-
-            full_list = [m for m in full_list if m[1] == service]
-
         if search_term is None:
             if name_only:
                 return [m[0] for m in full_list]

edsl/language_models/repair.py

@@ -141,6 +141,25 @@ def repair(
     return repair_wrapper(bad_json, error_message, user_prompt, system_prompt, cache)
 
 
+# Example usage:
+# result, success = repair_wrapper('{"name": "John Doe", "age": 30,}')  # example bad JSON
+
+
+# def repair_wrapper(bad_json, error_message=""):
+#     loop = asyncio.get_event_loop()
+#     if loop.is_running():
+#         # Add repair as a task to the running loop
+#         task = loop.create_task(repair(bad_json, error_message))
+#         return task
+#     else:
+#         # Run a new event loop for repair
+#         return loop.run_until_complete(repair(bad_json, error_message))
+
+
+# Example usage:
+# result, success = repair_wrapper('{"name": "John Doe", "age": 30,}')  # example bad JSON
+
+
 if __name__ == "__main__":
     bad_json = """
     {

edsl/prompts/Prompt.py

@@ -3,17 +3,13 @@ from typing import Optional
 from abc import ABC
 from typing import Any, List
 
-from jinja2 import Environment, FileSystemLoader
-from typing import Union, Dict
-from pathlib import Path
-
 from rich.table import Table
 from jinja2 import Template, Environment, meta, TemplateSyntaxError, Undefined
 
 
 class PreserveUndefined(Undefined):
     def __str__(self):
-        return "{{ " + str(self._undefined_name) + " }}"
+        return "{{ " + self._undefined_name + " }}"
 
 
 from edsl.exceptions.prompts import TemplateRenderError
@@ -74,50 +70,6 @@ class PromptBase(
             text = f.read()
         return cls(text=text)
 
-    @classmethod
-    def from_template(
-        cls,
-        file_name: str,
-        path_to_folder: Optional[Union[str, Path]] = None,
-        **kwargs: Dict[str, Any],
-    ) -> "PromptBase":
-        """Create a `PromptBase` from a Jinja template.
-
-        Args:
-            file_name (str): The name of the Jinja template file.
-            path_to_folder (Union[str, Path]): The path to the folder containing the template.
-                            Can be absolute or relative.
-            **kwargs: Variables to be passed to the template for rendering.
-
-        Returns:
-            PromptBase: An instance of PromptBase with the rendered template as text.
-        """
-        # if file_name lacks the .j2 extension, add it
-        if not file_name.endswith(".jinja"):
-            file_name += ".jinja"
-
-        # Convert path_to_folder to a Path object if it's a string
-        if path_to_folder is None:
-            from importlib import resources
-            import os
-
-            path_to_folder = resources.path("edsl.questions", "prompt_templates")
-
-        try:
-            folder_path = Path(path_to_folder)
-        except Exception as e:
-            raise ValueError(f"Invalid path: {path_to_folder}. Error: {e}")
-
-        with open(folder_path.joinpath(file_name), "r") as f:
-            text = f.read()
-        return cls(text=text)
-        # Resolve the path to get the absolute path
-        # absolute_path = folder_path.resolve()
-        # env = Environment(loader=FileSystemLoader(absolute_path))
-        # template = env.get_template(file_name)
-        # rendered_text = template.render({})
-        # return cls(text=rendered_text)
-
     @property
     def text(self):
         """Return the `Prompt` text."""
@@ -295,9 +247,7 @@ class PromptBase(
                 "Too much nesting - you created an infinite loop here, pal"
             )
         except TemplateSyntaxError as e:
-            raise TemplateRenderError(
-                f"Template syntax error: {e}. Bad template: {text}"
-            )
+            raise TemplateRenderError(f"Template syntax error: {e}")
 
     def to_dict(self) -> dict[str, Any]:
         """Return the `Prompt` as a dictionary.

edsl/questions/AnswerValidatorMixin.py

@@ -16,27 +16,19 @@ class AnswerValidatorMixin:
     - Question specific validation: validators for specific question types
     """
 
-    def failing_job(self):
-        from edsl import Agent
-
-        a = Agent()
-
-        def f(self, question, scenario):
-            return []
-
-        a.add_direct_question_answering_method(f, validate_response=True)
-        from edsl import QuestionNumerical
-
-        q = QuestionNumerical.example()
-        results = q.by(a).run()
-        return results
-
     #####################
     # TEMPLATE VALIDATION
     #####################
     def _validate_answer_template_basic(self, answer: Any) -> None:
         """Check that the answer (i) is a dictionary (ii) has an 'answer' key.
 
+        >>> avm = AnswerValidatorMixin()
+        >>> avm._validate_answer_template_basic({'answer': 1})
+        >>> avm._validate_answer_template_basic([])
+        Traceback (most recent call last):
+        ...
+        edsl.exceptions.questions.QuestionAnswerValidationError: Answer must be a dictionary (got []).
+
         - E.g., both {'answer': 1} and {'answer': {'a': 1}, 'other_key'=[1,2,3]} are valid
         """
         if not isinstance(answer, dict):
@@ -64,9 +56,14 @@ class AnswerValidatorMixin:
     def _validate_answer_key_value_numeric(
         self, answer: dict[str, Any], key: str
     ) -> None:
-        """Check that the value is numeric (int or float).
-        Can also deal with strings that contain commas and other characters.
-
+        """Check that the value of a key is numeric (int or float).
+
+        >>> avm = AnswerValidatorMixin()
+        >>> avm._validate_answer_key_value_numeric({'answer': 1}, 'answer')
+        >>> avm._validate_answer_key_value_numeric({'answer': 'poo'}, 'answer')
+        Traceback (most recent call last):
+        ...
+        edsl.exceptions.questions.QuestionAnswerValidationError: Answer should be numerical (int or float). Got 'poo'
         """
         value = answer.get(key)
         initial_value = value
@@ -131,6 +128,15 @@ class AnswerValidatorMixin:
 
         :param answer: Answer to validate
 
+        >>> avm = AnswerValidatorMixin()
+        >>> avm.question_options = ["a", "b", "c"]
+        >>> avm.min_selections = 1
+        >>> avm.max_selections = 2
+        >>> avm._validate_answer_checkbox({"answer": ["0", "1"]})
+        >>> avm._validate_answer_checkbox({"answer": []})
+        Traceback (most recent call last):
+        ...
+        edsl.exceptions.questions.QuestionAnswerValidationError:...
 
         Check that answer["answer"]:
         - has elements that are strings, bytes-like objects or real numbers evaluating to integers
@@ -281,9 +287,6 @@ class AnswerValidatorMixin:
 
 
 if __name__ == "__main__":
-    pass
-    # import doctest
-
-    # doctest.testmod(optionflags=doctest.ELLIPSIS)
+    import doctest
 
-    # results = AnswerValidatorMixin().failing_job()
+    doctest.testmod(optionflags=doctest.ELLIPSIS)