edsl 0.1.29.dev3__py3-none-any.whl → 0.1.30__py3-none-any.whl

edsl/language_models/LanguageModel.py

@@ -7,26 +7,18 @@ import asyncio
 import json
 import time
 import os
-
 from typing import Coroutine, Any, Callable, Type, List, get_type_hints
-
-from abc import ABC, abstractmethod, ABCMeta
-
-from rich.table import Table
+from abc import ABC, abstractmethod
 
 from edsl.config import CONFIG
 
-from edsl.utilities.utilities import clean_json
 from edsl.utilities.decorators import sync_wrapper, jupyter_nb_handler
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+
 from edsl.language_models.repair import repair
-from edsl.exceptions.language_models import LanguageModelAttributeTypeError
 from edsl.enums import InferenceServiceType
 from edsl.Base import RichPrintingMixin, PersistenceMixin
-from edsl.data.Cache import Cache
 from edsl.enums import service_to_api_keyname
-
-
 from edsl.exceptions import MissingAPIKeyError
 from edsl.language_models.RegisterLanguageModelsMeta import RegisterLanguageModelsMeta
 
@@ -291,7 +283,7 @@ class LanguageModel(
         self,
         user_prompt: str,
         system_prompt: str,
-        cache,
+        cache: "Cache",
         iteration: int = 0,
         encoded_image=None,
     ) -> tuple[dict, bool, str]:
@@ -331,12 +323,10 @@ class LanguageModel(
             image_hash = hashlib.md5(encoded_image.encode()).hexdigest()
             cache_call_params["user_prompt"] = f"{user_prompt} {image_hash}"
 
-        cached_response = cache.fetch(**cache_call_params)
-
+        cached_response, cache_key = cache.fetch(**cache_call_params)
         if cached_response:
             response = json.loads(cached_response)
             cache_used = True
-            cache_key = None
         else:
             remote_call = hasattr(self, "remote") and self.remote
             f = (
@@ -348,7 +338,7 @@ class LanguageModel(
             if encoded_image:
                 params["encoded_image"] = encoded_image
             response = await f(**params)
-            cache_key = cache.store(
+            new_cache_key = cache.store(
                 user_prompt=user_prompt,
                 model=str(self.model),
                 parameters=self.parameters,
@@ -356,6 +346,7 @@ class LanguageModel(
                 response=response,
                 iteration=iteration,
             )
+            assert new_cache_key == cache_key
             cache_used = False
 
         return response, cache_used, cache_key
@@ -420,7 +411,7 @@ class LanguageModel(
 
         dict_response.update(
             {
-                "cached_used": cache_used,
+                "cache_used": cache_used,
                 "cache_key": cache_key,
                 "usage": raw_response.get("usage", {}),
                 "raw_model_response": raw_response,
@@ -490,6 +481,8 @@ class LanguageModel(
 
     def rich_print(self):
         """Display an object as a table."""
+        from rich.table import Table
+
         table = Table(title="Language Model")
         table.add_column("Attribute", style="bold")
         table.add_column("Value")
@@ -501,7 +494,12 @@ class LanguageModel(
         return table
 
     @classmethod
-    def example(cls, test_model: bool = False, canned_response: str = "Hello world"):
+    def example(
+        cls,
+        test_model: bool = False,
+        canned_response: str = "Hello world",
+        throw_exception: bool = False,
+    ):
         """Return a default instance of the class.
 
         >>> from edsl.language_models import LanguageModel
@@ -526,6 +524,8 @@ class LanguageModel(
             ) -> dict[str, Any]:
                 await asyncio.sleep(0.1)
                 # return {"message": """{"answer": "Hello, world"}"""}
+                if throw_exception:
+                    raise Exception("This is a test error")
                 return {"message": f'{{"answer": "{canned_response}"}}'}
 
             def parse_response(self, raw_response: dict[str, Any]) -> str:

edsl/language_models/ModelList.py

@@ -5,7 +5,7 @@ from edsl import Model
 from edsl.language_models import LanguageModel
 from edsl.Base import Base
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
-from edsl.utilities import is_valid_variable_name
+from edsl.utilities.utilities import is_valid_variable_name
 from edsl.utilities.utilities import dict_hash
 
 

edsl/language_models/repair.py

@@ -1,18 +1,13 @@
 import json
 import asyncio
 import warnings
-from rich import print
-from rich.console import Console
-from rich.syntax import Syntax
-
-from edsl.utilities.utilities import clean_json
-
-from edsl.utilities.repair_functions import extract_json_from_string
 
 
 async def async_repair(
     bad_json, error_message="", user_prompt=None, system_prompt=None, cache=None
 ):
+    from edsl.utilities.utilities import clean_json
+
     s = clean_json(bad_json)
 
     try:
@@ -27,6 +22,8 @@ async def async_repair(
         return valid_dict, success
 
     try:
+        from edsl.utilities.repair_functions import extract_json_from_string
+
         valid_dict = extract_json_from_string(s)
         success = True
     except ValueError:
@@ -98,6 +95,10 @@ async def async_repair(
     except json.JSONDecodeError:
         valid_dict = {}
         success = False
+        from rich import print
+        from rich.console import Console
+        from rich.syntax import Syntax
+
         console = Console()
         error_message = (
             f"All repairs. failed. LLM Model given [red]{str(bad_json)}[/red]"

edsl/notebooks/Notebook.py

@@ -1,15 +1,11 @@
 """A Notebook is a utility class that allows you to easily share/pull ipynbs from Coop."""
 
+from __future__ import annotations
 import json
-import nbformat
-from nbconvert import HTMLExporter
 from typing import Dict, List, Optional
-from rich.table import Table
+from uuid import uuid4
 from edsl.Base import Base
-from edsl.utilities.decorators import (
-    add_edsl_version,
-    remove_edsl_version,
-)
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 class Notebook(Base):
@@ -34,6 +30,8 @@ class Notebook(Base):
         If no path is provided, assume this code is run in a notebook and try to load the current notebook from file.
         :param name: A name for the Notebook.
         """
+        import nbformat
+
         # Load current notebook path as fallback (VS Code only)
         path = path or globals().get("__vsc_ipynb_file__")
         if data is not None:
@@ -56,6 +54,37 @@ class Notebook(Base):
 
         self.name = name or self.default_name
 
+    @classmethod
+    def from_script(cls, path: str, name: Optional[str] = None) -> "Notebook":
+        # Read the script file
+        with open(path, "r") as script_file:
+            script_content = script_file.read()
+
+        # Create a new Jupyter notebook
+        nb = nbformat.v4.new_notebook()
+
+        # Add the script content to the first cell
+        first_cell = nbformat.v4.new_code_cell(script_content)
+        nb.cells.append(first_cell)
+
+        # Create a Notebook instance with the notebook data
+        notebook_instance = cls(nb)
+
+        return notebook_instance
+
+    @classmethod
+    def from_current_script(cls) -> "Notebook":
+        import inspect
+        import os
+
+        # Get the path to the current file
+        current_frame = inspect.currentframe()
+        caller_frame = inspect.getouterframes(current_frame, 2)
+        current_file_path = os.path.abspath(caller_frame[1].filename)
+
+        # Use from_script to create the notebook
+        return cls.from_script(current_file_path)
+
     def __eq__(self, other):
         """
         Check if two Notebooks are equal.
@@ -103,6 +132,9 @@ class Notebook(Base):
         """
         Return HTML representation of Notebook.
         """
+        from nbconvert import HTMLExporter
+        import nbformat
+
         notebook = nbformat.from_dict(self.data)
         html_exporter = HTMLExporter(template_name="basic")
         (body, _) = html_exporter.from_notebook_node(notebook)
@@ -143,6 +175,8 @@ class Notebook(Base):
         """
         Display a Notebook as a rich table.
         """
+        from rich.table import Table
+
         table_data, column_names = self._table()
         table = Table(title=f"{self.__class__.__name__} Attributes")
         for column in column_names:
@@ -155,10 +189,13 @@ class Notebook(Base):
         return table
 
     @classmethod
-    def example(cls) -> "Notebook":
+    def example(cls, randomize: bool = False) -> Notebook:
         """
-        Return an example Notebook.
+        Returns an example Notebook instance.
+
+        :param randomize: If True, adds a random string one of the cells' output.
         """
+        addition = "" if not randomize else str(uuid4())
         cells = [
             {
                 "cell_type": "markdown",
@@ -173,7 +210,7 @@ class Notebook(Base):
                     {
                         "name": "stdout",
                         "output_type": "stream",
-                        "text": "Hello world!\n",
+                        "text": f"Hello world!\n{addition}",
                     }
                 ],
                 "source": 'print("Hello world!")',

edsl/prompts/Prompt.py

@@ -1,12 +1,16 @@
-"""Class for creating prompts to be used in a survey."""
-
 from __future__ import annotations
 from typing import Optional
 from abc import ABC
 from typing import Any, List
 
 from rich.table import Table
-from jinja2 import Template, Environment, meta, TemplateSyntaxError
+from jinja2 import Template, Environment, meta, TemplateSyntaxError, Undefined
+
+
+class PreserveUndefined(Undefined):
+    def __str__(self):
+        return "{{ " + self._undefined_name + " }}"
+
 
 from edsl.exceptions.prompts import TemplateRenderError
 from edsl.prompts.prompt_config import (
@@ -35,6 +39,10 @@ class PromptBase(
 
         return data_to_html(self.to_dict())
 
+    def __len__(self):
+        """Return the length of the prompt text."""
+        return len(self.text)
+
     @classmethod
     def prompt_attributes(cls) -> List[str]:
         """Return the prompt class attributes."""
@@ -75,10 +83,10 @@ class PromptBase(
         >>> p = Prompt("Hello, {{person}}")
         >>> p2 = Prompt("How are you?")
         >>> p + p2
-        Prompt(text='Hello, {{person}}How are you?')
+        Prompt(text=\"""Hello, {{person}}How are you?\""")
 
         >>> p + "How are you?"
-        Prompt(text='Hello, {{person}}How are you?')
+        Prompt(text=\"""Hello, {{person}}How are you?\""")
         """
         if isinstance(other_prompt, str):
             return self.__class__(self.text + other_prompt)
@@ -114,7 +122,7 @@ class PromptBase(
         Example:
         >>> p = Prompt("Hello, {{person}}")
         >>> p
-        Prompt(text='Hello, {{person}}')
+        Prompt(text=\"""Hello, {{person}}\""")
         """
         return f'Prompt(text="""{self.text}""")'
 
@@ -137,7 +145,7 @@ class PromptBase(
         :param template: The template to find the variables in.
 
         """
-        env = Environment()
+        env = Environment(undefined=PreserveUndefined)
         ast = env.parse(template)
         return list(meta.find_undeclared_variables(ast))
 
@@ -186,13 +194,16 @@ class PromptBase(
 
         >>> p = Prompt("Hello, {{person}}")
         >>> p.render({"person": "John"})
-        'Hello, John'
+        Prompt(text=\"""Hello, John\""")
 
         >>> p.render({"person": "Mr. {{last_name}}", "last_name": "Horton"})
-        'Hello, Mr. Horton'
+        Prompt(text=\"""Hello, Mr. Horton\""")
 
         >>> p.render({"person": "Mr. {{last_name}}", "last_name": "Ho{{letter}}ton"}, max_nesting = 1)
-        'Hello, Mr. Horton'
+        Prompt(text=\"""Hello, Mr. Ho{{ letter }}ton\""")
+
+        >>> p.render({"person": "Mr. {{last_name}}"})
+        Prompt(text=\"""Hello, Mr. {{ last_name }}\""")
         """
         new_text = self._render(
             self.text, primary_replacement, **additional_replacements
@@ -216,12 +227,13 @@ class PromptBase(
         >>> codebook = {"age": "Age"}
         >>> p = Prompt("You are an agent named {{ name }}. {{ codebook['age']}}: {{ age }}")
         >>> p.render({"name": "John", "age": 44}, codebook=codebook)
-        'You are an agent named John. Age: 44'
+        Prompt(text=\"""You are an agent named John. Age: 44\""")
         """
+        env = Environment(undefined=PreserveUndefined)
         try:
             previous_text = None
             for _ in range(MAX_NESTING):
-                rendered_text = Template(text).render(
+                rendered_text = env.from_string(text).render(
                     primary_replacement, **additional_replacements
                 )
                 if rendered_text == previous_text:
@@ -258,7 +270,7 @@ class PromptBase(
         >>> p = Prompt("Hello, {{person}}")
         >>> p2 = Prompt.from_dict(p.to_dict())
         >>> p2
-        Prompt(text='Hello, {{person}}')
+        Prompt(text=\"""Hello, {{person}}\""")
 
         """
         class_name = data["class_name"]
@@ -290,6 +302,12 @@ class Prompt(PromptBase):
     component_type = ComponentTypes.GENERIC
 
 
+if __name__ == "__main__":
+    print("Running doctests...")
+    import doctest
+
+    doctest.testmod()
+
 from edsl.prompts.library.question_multiple_choice import *
 from edsl.prompts.library.agent_instructions import *
 from edsl.prompts.library.agent_persona import *
@@ -302,9 +320,3 @@ from edsl.prompts.library.question_numerical import *
 from edsl.prompts.library.question_rank import *
 from edsl.prompts.library.question_extract import *
 from edsl.prompts.library.question_list import *
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/questions/QuestionBase.py

@@ -1,8 +1,8 @@
 """This module contains the Question class, which is the base class for all questions in EDSL."""
 
 from __future__ import annotations
+import time
 from abc import ABC, abstractmethod
-from rich.table import Table
 from typing import Any, Type, Optional, List, Callable
 import copy
 
@@ -12,7 +12,7 @@ from edsl.exceptions import (
 )
 from edsl.questions.descriptors import QuestionNameDescriptor, QuestionTextDescriptor
 
-from edsl.prompts.registry import get_classes as prompt_lookup
+
 from edsl.questions.AnswerValidatorMixin import AnswerValidatorMixin
 from edsl.questions.RegisterQuestionsMeta import RegisterQuestionsMeta
 from edsl.Base import PersistenceMixin, RichPrintingMixin
@@ -124,6 +124,8 @@ class QuestionBase(
         :param model: The language model to use. If None, assumes does not matter.
 
         """
+        from edsl.prompts.registry import get_classes as prompt_lookup
+
         applicable_prompts = prompt_lookup(
             component_type="question_instructions",
             question_type=cls.question_type,
@@ -173,15 +175,16 @@ class QuestionBase(
     def add_model_instructions(
         self, *, instructions: str, model: Optional[str] = None
     ) -> None:
-        """Add model-specific instructions for the question.
+        """Add model-specific instructions for the question that override the default instructions.
 
         :param instructions: The instructions to add. This is typically a jinja2 template.
         :param model: The language model for this instruction.
 
         >>> from edsl.questions import QuestionFreeText
         >>> q = QuestionFreeText(question_name = "color", question_text = "What is your favorite color?")
-        >>> q.add_model_instructions(instructions = "Answer in valid JSON like so {'answer': 'comment: <>}", model = "gpt3")
-
+        >>> q.add_model_instructions(instructions = "{{question_text}}. Answer in valid JSON like so {'answer': 'comment: <>}", model = "gpt3")
+        >>> q.get_instructions(model = "gpt3")
+        Prompt(text=\"""{{question_text}}. Answer in valid JSON like so {'answer': 'comment: <>}\""")
         """
         from edsl import Model
 
@@ -201,6 +204,13 @@ class QuestionBase(
         """Get the mathcing question-answering instructions for the question.
 
         :param model: The language model to use.
+
+        >>> from edsl import QuestionFreeText
+        >>> QuestionFreeText.example().get_instructions()
+        Prompt(text=\"""You are being asked the following question: {{question_text}}
+        Return a valid JSON formatted like this:
+        {"answer": "<put free text answer here>"}
+        \""")
         """
         from edsl.prompts.Prompt import Prompt
 
@@ -293,7 +303,16 @@ class QuestionBase(
         print_json(json.dumps(self.to_dict()))
 
     def __call__(self, just_answer=True, model=None, agent=None, **kwargs):
-        """Call the question."""
+        """Call the question.
+
+        >>> from edsl.language_models import LanguageModel
+        >>> m = LanguageModel.example(canned_response = "Yo, what's up?", test_model = True)
+        >>> from edsl import QuestionFreeText
+        >>> q = QuestionFreeText(question_name = "color", question_text = "What is your favorite color?")
+        >>> q(model = m)
+        "Yo, what's up?"
+
+        """
         survey = self.to_survey()
         results = survey(model=model, agent=agent, **kwargs)
         if just_answer:
@@ -304,7 +323,6 @@ class QuestionBase(
     async def run_async(self, just_answer=True, model=None, agent=None, **kwargs):
         """Call the question."""
         survey = self.to_survey()
-        ## asyncio.run(survey.async_call());
         results = await survey.run_async(model=model, agent=agent, **kwargs)
         if just_answer:
             return results.select(f"answer.{self.question_name}").first()
@@ -383,29 +401,34 @@ class QuestionBase(
         s = Survey([self, other])
         return s
 
-    def to_survey(self):
+    def to_survey(self) -> "Survey":
         """Turn a single question into a survey."""
         from edsl.surveys.Survey import Survey
 
         s = Survey([self])
         return s
 
-    def run(self, *args, **kwargs):
+    def run(self, *args, **kwargs) -> "Results":
         """Turn a single question into a survey and run it."""
         from edsl.surveys.Survey import Survey
 
         s = self.to_survey()
         return s.run(*args, **kwargs)
 
-    def by(self, *args):
-        """Turn a single question into a survey and run it."""
+    def by(self, *args) -> "Jobs":
+        """Turn a single question into a survey and then a Job."""
         from edsl.surveys.Survey import Survey
 
         s = Survey([self])
         return s.by(*args)
 
-    def human_readable(self):
-        """Print the question in a human readable format."""
+    def human_readable(self) -> str:
+        """Print the question in a human readable format.
+
+        >>> from edsl.questions import QuestionFreeText
+        >>> QuestionFreeText.example().human_readable()
+        'Question Type: free_text\\nQuestion: How are you?'
+        """
         lines = []
         lines.append(f"Question Type: {self.question_type}")
         lines.append(f"Question: {self.question_text}")
@@ -475,6 +498,8 @@ class QuestionBase(
 
     def rich_print(self):
         """Print the question in a rich format."""
+        from rich.table import Table
+
         table = Table(show_header=True, header_style="bold magenta")
         table.add_column("Question Name", style="dim")
         table.add_column("Question Type")

edsl/questions/QuestionBudget.py

@@ -1,11 +1,8 @@
 from __future__ import annotations
 import random
-import textwrap
 from typing import Any, Optional, Union
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import IntegerDescriptor, QuestionOptionsDescriptor
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionBudget(QuestionBase):
@@ -46,7 +43,7 @@ class QuestionBudget(QuestionBase):
         return answer
 
     def _translate_answer_code_to_answer(
-        self, answer_codes: dict[str, int], scenario: Scenario = None
+        self, answer_codes: dict[str, int], scenario: "Scenario" = None
     ):
         """
         Translate the answer codes to the actual answers.
@@ -63,6 +60,8 @@ class QuestionBudget(QuestionBase):
 
     def _simulate_answer(self, human_readable=True):
         """Simulate a valid answer for debugging purposes (what the validator expects)."""
+        from edsl.utilities.utilities import random_string
+
         if human_readable:
             keys = self.question_options
         else:
@@ -163,8 +162,8 @@ def main():
 
 
 if __name__ == "__main__":
-    q = QuestionBudget.example()
-    results = q.run()
+    # q = QuestionBudget.example()
+    # results = q.run()
 
     import doctest
 

edsl/questions/QuestionCheckBox.py

@@ -9,8 +9,6 @@ from edsl.questions.descriptors import (
     IntegerDescriptor,
     QuestionOptionsDescriptor,
 )
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionCheckBox(QuestionBase):
@@ -55,13 +53,17 @@ class QuestionCheckBox(QuestionBase):
         self._validate_answer_checkbox(answer)
         return answer
 
-    def _translate_answer_code_to_answer(self, answer_codes, scenario: Scenario = None):
+    def _translate_answer_code_to_answer(
+        self, answer_codes, scenario: "Scenario" = None
+    ):
         """
         Translate the answer code to the actual answer.
 
         For example, for question options ["a", "b", "c"],the answer codes are 0, 1, and 2.
         The LLM will respond with [0,1] and this code will translate it to ["a","b"].
         """
+        from edsl.scenarios.Scenario import Scenario
+
         scenario = scenario or Scenario()
         translated_options = [
             Template(option).render(scenario) for option in self.question_options
@@ -73,6 +75,8 @@ class QuestionCheckBox(QuestionBase):
 
     def _simulate_answer(self, human_readable=True) -> dict[str, Union[int, str]]:
         """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
         min_selections = self.min_selections or 1
         max_selections = self.max_selections or len(self.question_options)
         num_selections = random.randint(min_selections, max_selections)

edsl/questions/QuestionExtract.py

@@ -2,8 +2,6 @@ from __future__ import annotations
 from typing import Any
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import AnswerTemplateDescriptor
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionExtract(QuestionBase):
@@ -44,12 +42,14 @@ class QuestionExtract(QuestionBase):
         self._validate_answer_extract(answer)
         return answer
 
-    def _translate_answer_code_to_answer(self, answer, scenario: Scenario = None):
+    def _translate_answer_code_to_answer(self, answer, scenario: "Scenario" = None):
         """Return the answer in a human-readable format."""
         return answer
 
     def _simulate_answer(self, human_readable: bool = True) -> dict[str, str]:
         """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
         return {
             "answer": {key: random_string() for key in self.answer_template.keys()},
             "comment": random_string(),
@@ -106,6 +106,8 @@ def main():
     q.to_dict()
     assert q.from_dict(q.to_dict()) == q
 
+
+if __name__ == "__main__":
     import doctest
 
     doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/questions/QuestionFreeText.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 import textwrap
 from typing import Any, Optional
+from uuid import uuid4
 from edsl.questions.QuestionBase import QuestionBase
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionFreeText(QuestionBase):
@@ -43,12 +42,14 @@ class QuestionFreeText(QuestionBase):
         self._validate_answer_key_value(answer, "answer", str)
         return answer
 
-    def _translate_answer_code_to_answer(self, answer, scenario: Scenario = None):
+    def _translate_answer_code_to_answer(self, answer, scenario: "Scenario" = None):
         """Do nothing, because the answer is already in a human-readable format."""
         return answer
 
     def _simulate_answer(self, human_readable: bool = True) -> dict[str, str]:
         """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
         return {"answer": random_string()}
 
     @property
@@ -65,9 +66,10 @@ class QuestionFreeText(QuestionBase):
         return question_html_content
 
     @classmethod
-    def example(cls) -> QuestionFreeText:
+    def example(cls, randomize: bool = False) -> QuestionFreeText:
         """Return an example instance of a free text question."""
-        return cls(question_name="how_are_you", question_text="How are you?")
+        addition = "" if not randomize else str(uuid4())
+        return cls(question_name="how_are_you", question_text=f"How are you?{addition}")
 
 
 def main():