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

edsl/jobs/runners/JobsRunnerAsyncio.py

@@ -1,17 +1,29 @@
 from __future__ import annotations
 import time
 import asyncio
-import time
+import textwrap
 from contextlib import contextmanager
 
 from typing import Coroutine, List, AsyncGenerator, Optional, Union
 
+from rich.live import Live
+from rich.console import Console
+
 from edsl import shared_globals
+from edsl.results import Results, Result
+
 from edsl.jobs.interviews.Interview import Interview
+from edsl.utilities.decorators import jupyter_nb_handler
+
+# from edsl.jobs.Jobs import Jobs
 from edsl.jobs.runners.JobsRunnerStatusMixin import JobsRunnerStatusMixin
+from edsl.language_models import LanguageModel
+from edsl.data.Cache import Cache
+
 from edsl.jobs.tasks.TaskHistory import TaskHistory
 from edsl.jobs.buckets.BucketCollection import BucketCollection
-from edsl.utilities.decorators import jupyter_nb_handler
+
+import time
 
 
 class JobsRunnerAsyncio(JobsRunnerStatusMixin):
@@ -30,13 +42,13 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
 
     async def run_async_generator(
         self,
-        cache: "Cache",
+        cache: Cache,
         n: int = 1,
         debug: bool = False,
         stop_on_exception: bool = False,
         sidecar_model: "LanguageModel" = None,
         total_interviews: Optional[List["Interview"]] = None,
-    ) -> AsyncGenerator["Result", None]:
+    ) -> AsyncGenerator[Result, None]:
         """Creates the tasks, runs them asynchronously, and returns the results as a Results object.
 
         Completed tasks are yielded as they are completed.
@@ -143,21 +155,19 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
 
         prompt_dictionary = {}
         for answer_key_name in answer_key_names:
-            prompt_dictionary[answer_key_name + "_user_prompt"] = (
-                question_name_to_prompts[answer_key_name]["user_prompt"]
-            )
-            prompt_dictionary[answer_key_name + "_system_prompt"] = (
-                question_name_to_prompts[answer_key_name]["system_prompt"]
-            )
+            prompt_dictionary[
+                answer_key_name + "_user_prompt"
+            ] = question_name_to_prompts[answer_key_name]["user_prompt"]
+            prompt_dictionary[
+                answer_key_name + "_system_prompt"
+            ] = question_name_to_prompts[answer_key_name]["system_prompt"]
 
         raw_model_results_dictionary = {}
         for result in valid_results:
             question_name = result["question_name"]
-            raw_model_results_dictionary[question_name + "_raw_model_response"] = (
-                result["raw_model_response"]
-            )
-
-        from edsl.results.Result import Result
+            raw_model_results_dictionary[
+                question_name + "_raw_model_response"
+            ] = result["raw_model_response"]
 
         result = Result(
             agent=interview.agent,
@@ -187,8 +197,6 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
         print_exceptions: bool = True,
     ) -> "Coroutine":
         """Runs a collection of interviews, handling both async and sync contexts."""
-        from rich.console import Console
-
         console = Console()
         self.results = []
         self.start_time = time.monotonic()
@@ -196,8 +204,6 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
         self.cache = cache
         self.sidecar_model = sidecar_model
 
-        from edsl.results.Results import Results
-
         if not progress_bar:
             # print("Running without progress bar")
             with cache as c:
@@ -219,8 +225,6 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
             results = Results(survey=self.jobs.survey, data=self.results)
         else:
             # print("Running with progress bar")
-            from rich.live import Live
-            from rich.console import Console
 
             def generate_table():
                 return self.status_table(self.results, self.elapsed_time)

edsl/jobs/tasks/TaskHistory.py

@@ -1,5 +1,8 @@
 from edsl.jobs.tasks.task_status_enum import TaskStatus
+from matplotlib import pyplot as plt
 from typing import List, Optional
+
+import matplotlib.pyplot as plt
 from io import BytesIO
 import base64
 
@@ -72,8 +75,6 @@ class TaskHistory:
 
     def plot_completion_times(self):
         """Plot the completion times for each task."""
-        import matplotlib.pyplot as plt
-
         updates = self.get_updates()
 
         elapsed = [update.max_time - update.min_time for update in updates]
@@ -125,8 +126,6 @@ class TaskHistory:
         rows = int(len(TaskStatus) ** 0.5) + 1
         cols = (len(TaskStatus) + rows - 1) // rows  # Ensure all plots fit
 
-        import matplotlib.pyplot as plt
-
         fig, axes = plt.subplots(rows, cols, figsize=(15, 10))
         axes = axes.flatten()  # Flatten in case of a single row/column
 

edsl/language_models/LanguageModel.py

@@ -7,18 +7,26 @@ import asyncio
 import json
 import time
 import os
+
 from typing import Coroutine, Any, Callable, Type, List, get_type_hints
-from abc import ABC, abstractmethod
+
+from abc import ABC, abstractmethod, ABCMeta
+
+from rich.table import Table
 
 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
 
@@ -283,7 +291,7 @@ class LanguageModel(
         self,
         user_prompt: str,
         system_prompt: str,
-        cache: "Cache",
+        cache,
         iteration: int = 0,
         encoded_image=None,
     ) -> tuple[dict, bool, str]:
@@ -482,8 +490,6 @@ 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")

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.utilities import is_valid_variable_name
+from edsl.utilities import is_valid_variable_name
 from edsl.utilities.utilities import dict_hash
 
 
@@ -56,11 +56,11 @@ class ModelList(Base, UserList):
             return {"models": [model._to_dict() for model in self]}
 
     @classmethod
-    def from_names(self, *args, **kwargs):
+    def from_names(self, *args):
         """A a model list from a list of names"""
         if len(args) == 1 and isinstance(args[0], list):
             args = args[0]
-        return ModelList([Model(model_name, **kwargs) for model_name in args])
+        return ModelList([Model(model_name) for model_name in args])
 
     @add_edsl_version
     def to_dict(self):

edsl/language_models/repair.py

@@ -1,13 +1,18 @@
 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:
@@ -22,8 +27,6 @@ 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:
@@ -95,10 +98,6 @@ 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,9 +1,10 @@
 """A Notebook is a utility class that allows you to easily share/pull ipynbs from Coop."""
 
 import json
+import nbformat
+from nbconvert import HTMLExporter
 from typing import Dict, List, Optional
-
-
+from rich.table import Table
 from edsl.Base import Base
 from edsl.utilities.decorators import (
     add_edsl_version,
@@ -33,8 +34,6 @@ 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:
@@ -57,37 +56,6 @@ 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.
@@ -135,9 +103,6 @@ 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)
@@ -178,8 +143,6 @@ 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:

edsl/prompts/Prompt.py

@@ -1,16 +1,12 @@
+"""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, Undefined
-
-
-class PreserveUndefined(Undefined):
-    def __str__(self):
-        return "{{ " + self._undefined_name + " }}"
-
+from jinja2 import Template, Environment, meta, TemplateSyntaxError
 
 from edsl.exceptions.prompts import TemplateRenderError
 from edsl.prompts.prompt_config import (
@@ -39,10 +35,6 @@ 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."""
@@ -83,10 +75,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)
@@ -122,7 +114,7 @@ class PromptBase(
         Example:
         >>> p = Prompt("Hello, {{person}}")
         >>> p
-        Prompt(text=\"""Hello, {{person}}\""")
+        Prompt(text='Hello, {{person}}')
         """
         return f'Prompt(text="""{self.text}""")'
 
@@ -145,7 +137,7 @@ class PromptBase(
         :param template: The template to find the variables in.
 
         """
-        env = Environment(undefined=PreserveUndefined)
+        env = Environment()
         ast = env.parse(template)
         return list(meta.find_undeclared_variables(ast))
 
@@ -194,16 +186,13 @@ class PromptBase(
 
         >>> p = Prompt("Hello, {{person}}")
         >>> p.render({"person": "John"})
-        Prompt(text=\"""Hello, John\""")
+        'Hello, John'
 
         >>> p.render({"person": "Mr. {{last_name}}", "last_name": "Horton"})
-        Prompt(text=\"""Hello, Mr. Horton\""")
+        'Hello, Mr. Horton'
 
         >>> p.render({"person": "Mr. {{last_name}}", "last_name": "Ho{{letter}}ton"}, max_nesting = 1)
-        Prompt(text=\"""Hello, Mr. Ho{{ letter }}ton\""")
-
-        >>> p.render({"person": "Mr. {{last_name}}"})
-        Prompt(text=\"""Hello, Mr. {{ last_name }}\""")
+        'Hello, Mr. Horton'
         """
         new_text = self._render(
             self.text, primary_replacement, **additional_replacements
@@ -227,13 +216,12 @@ class PromptBase(
         >>> codebook = {"age": "Age"}
         >>> p = Prompt("You are an agent named {{ name }}. {{ codebook['age']}}: {{ age }}")
         >>> p.render({"name": "John", "age": 44}, codebook=codebook)
-        Prompt(text=\"""You are an agent named John. Age: 44\""")
+        'You are an agent named John. Age: 44'
         """
-        env = Environment(undefined=PreserveUndefined)
         try:
             previous_text = None
             for _ in range(MAX_NESTING):
-                rendered_text = env.from_string(text).render(
+                rendered_text = Template(text).render(
                     primary_replacement, **additional_replacements
                 )
                 if rendered_text == previous_text:
@@ -270,7 +258,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"]
@@ -302,12 +290,6 @@ 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 *
@@ -320,3 +302,9 @@ 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,8 +124,6 @@ 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,
@@ -175,16 +173,15 @@ class QuestionBase(
     def add_model_instructions(
         self, *, instructions: str, model: Optional[str] = None
     ) -> None:
-        """Add model-specific instructions for the question that override the default instructions.
+        """Add model-specific instructions for the question.
 
         :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 = "{{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: <>}\""")
+        >>> q.add_model_instructions(instructions = "Answer in valid JSON like so {'answer': 'comment: <>}", model = "gpt3")
+
         """
         from edsl import Model
 
@@ -204,13 +201,6 @@ 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
 
@@ -303,16 +293,7 @@ class QuestionBase(
         print_json(json.dumps(self.to_dict()))
 
     def __call__(self, just_answer=True, model=None, agent=None, **kwargs):
-        """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?"
-
-        """
+        """Call the question."""
         survey = self.to_survey()
         results = survey(model=model, agent=agent, **kwargs)
         if just_answer:
@@ -323,6 +304,7 @@ 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()
@@ -401,34 +383,29 @@ class QuestionBase(
         s = Survey([self, other])
         return s
 
-    def to_survey(self) -> "Survey":
+    def to_survey(self):
         """Turn a single question into a survey."""
         from edsl.surveys.Survey import Survey
 
         s = Survey([self])
         return s
 
-    def run(self, *args, **kwargs) -> "Results":
+    def run(self, *args, **kwargs):
         """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) -> "Jobs":
-        """Turn a single question into a survey and then a Job."""
+    def by(self, *args):
+        """Turn a single question into a survey and run it."""
         from edsl.surveys.Survey import Survey
 
         s = Survey([self])
         return s.by(*args)
 
-    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?'
-        """
+    def human_readable(self):
+        """Print the question in a human readable format."""
         lines = []
         lines.append(f"Question Type: {self.question_type}")
         lines.append(f"Question: {self.question_text}")
@@ -498,8 +475,6 @@ 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,8 +1,11 @@
 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):
@@ -43,7 +46,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.
@@ -60,8 +63,6 @@ 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:
@@ -162,8 +163,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,6 +9,8 @@ from edsl.questions.descriptors import (
     IntegerDescriptor,
     QuestionOptionsDescriptor,
 )
+from edsl.scenarios import Scenario
+from edsl.utilities import random_string
 
 
 class QuestionCheckBox(QuestionBase):
@@ -53,17 +55,13 @@ 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
@@ -75,8 +73,6 @@ 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)