edsl 0.1.29.dev6__py3-none-any.whl → 0.1.30.dev1__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]:
@@ -490,6 +482,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")

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,10 +1,9 @@
 """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,
@@ -34,6 +33,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:
@@ -134,6 +135,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)
@@ -174,6 +178,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:

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,
@@ -496,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

@@ -2,8 +2,6 @@ from __future__ import annotations
 import textwrap
 from typing import Any, Optional
 from edsl.questions.QuestionBase import QuestionBase
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionFreeText(QuestionBase):
@@ -43,12 +41,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

edsl/questions/QuestionFunctional.py

@@ -1,10 +1,7 @@
 from typing import Optional, Callable
-from edsl.questions.QuestionBase import QuestionBase
-from edsl.questions.descriptors import FunctionDescriptor
 import inspect
 
 from edsl.questions.QuestionBase import QuestionBase
-from edsl.questions.descriptors import FunctionDescriptor
 
 from edsl.utilities.restricted_python import create_restricted_function
 

edsl/questions/QuestionList.py

@@ -5,9 +5,6 @@ from typing import Any, Optional, Union
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import IntegerOrNoneDescriptor
 
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
-
 
 class QuestionList(QuestionBase):
     """This question prompts the agent to answer by providing a list of items as comma-separated strings."""
@@ -42,13 +39,15 @@ class QuestionList(QuestionBase):
         self._validate_answer_list(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):
         """There is no answer code."""
         return answer
 
     def _simulate_answer(self, human_readable: bool = True):
         """Simulate a valid answer for debugging purposes (what the validator expects)."""
         num_items = random.randint(1, self.max_list_items or 2)
+        from edsl.utilities.utilities import random_string
+
         return {"answer": [random_string() for _ in range(num_items)]}
 
     @property

edsl/questions/QuestionMultipleChoice.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
-from typing import Optional, Union
+import time
+from typing import Union
 import random
 
 from jinja2 import Template
 
-from edsl.utilities import random_string
-from edsl.questions.descriptors import QuestionOptionsDescriptor
 from edsl.questions.QuestionBase import QuestionBase
-from edsl.scenarios import Scenario
+from edsl.questions.descriptors import QuestionOptionsDescriptor
 
 
 class QuestionMultipleChoice(QuestionBase):
@@ -47,8 +46,12 @@ class QuestionMultipleChoice(QuestionBase):
         self._validate_answer_multiple_choice(answer)
         return answer
 
-    def _translate_answer_code_to_answer(self, answer_code, scenario: Scenario = None):
+    def _translate_answer_code_to_answer(
+        self, answer_code, scenario: "Scenario" = None
+    ):
         """Translate the answer code to the actual answer."""
+        from edsl.scenarios.Scenario import Scenario
+
         scenario = scenario or Scenario()
         translated_options = [
             Template(str(option)).render(scenario) for option in self.question_options
@@ -59,6 +62,8 @@ class QuestionMultipleChoice(QuestionBase):
         self, human_readable: bool = True
     ) -> dict[str, Union[int, str]]:
         """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
         if human_readable:
             answer = random.choice(self.question_options)
         else:
@@ -127,6 +132,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/QuestionNumerical.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 import textwrap
 from random import uniform
 from typing import Any, Optional, Union
+
 from edsl.exceptions import QuestionAnswerValidationError
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.questions.descriptors import NumericalOrNoneDescriptor
-from edsl.scenarios import Scenario
-from edsl.utilities import random_string
 
 
 class QuestionNumerical(QuestionBase):
@@ -48,12 +47,14 @@ class QuestionNumerical(QuestionBase):
         self._validate_answer_numerical(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):
         """There is no answer code."""
         return answer
 
     def _simulate_answer(self, human_readable: bool = True):
         """Simulate a valid answer for debugging purposes."""
+        from edsl.utilities.utilities import random_string
+
         return {
             "answer": uniform(self.min_value, self.max_value),
             "comment": random_string(),

edsl/questions/QuestionRank.py

@@ -1,12 +1,10 @@
 from __future__ import annotations
 import random
-import textwrap
 from jinja2 import Template
 from typing import Any, Optional, Union
 from edsl.questions.QuestionBase import QuestionBase
 from edsl.exceptions import QuestionAnswerValidationError
-from edsl.scenarios import Scenario
-from edsl.utilities.utilities import random_string
+
 from edsl.questions.descriptors import (
     QuestionOptionsDescriptor,
     NumSelectionsDescriptor,
@@ -55,6 +53,8 @@ class QuestionRank(QuestionBase):
         self, answer_codes, scenario: Scenario = None
     ) -> list[str]:
         """Translate the answer code to the actual answer."""
+        from edsl.scenarios import Scenario
+
         scenario = scenario or Scenario()
         translated_options = [
             Template(option).render(scenario) for option in self.question_options
@@ -66,6 +66,8 @@ class QuestionRank(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
+
         if human_readable:
             selected = random.sample(self.question_options, self.num_selections)
         else:

edsl/questions/__init__.py

@@ -10,17 +10,18 @@ from edsl.questions.QuestionBudget import QuestionBudget
 from edsl.questions.QuestionCheckBox import QuestionCheckBox
 from edsl.questions.QuestionExtract import QuestionExtract
 from edsl.questions.QuestionFreeText import QuestionFreeText
+
 from edsl.questions.QuestionFunctional import QuestionFunctional
 from edsl.questions.QuestionList import QuestionList
 from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
 from edsl.questions.QuestionNumerical import QuestionNumerical
 from edsl.questions.QuestionRank import QuestionRank
 
-# Questions derived from core questions
+# # Questions derived from core questions
 from edsl.questions.derived.QuestionLikertFive import QuestionLikertFive
 from edsl.questions.derived.QuestionLinearScale import QuestionLinearScale
 from edsl.questions.derived.QuestionTopK import QuestionTopK
 from edsl.questions.derived.QuestionYesNo import QuestionYesNo
 
-# Compose Questions
-from edsl.questions.compose_questions import compose_questions
+# # Compose Questions
+# from edsl.questions.compose_questions import compose_questions

edsl/questions/descriptors.py

@@ -8,9 +8,7 @@ from edsl.exceptions import (
     QuestionAnswerValidationError,
 )
 from edsl.questions.settings import Settings
-from edsl.utilities.utilities import is_valid_variable_name
 
-from edsl.prompts import get_classes
 
 ################################
 # Helper functions
@@ -56,6 +54,8 @@ class BaseDescriptor(ABC):
     def __set__(self, instance, value: Any) -> None:
         """Set the value of the attribute."""
         self.validate(value, instance)
+        from edsl.prompts.registry import get_classes
+
         instance.__dict__[self.name] = value
         if self.name == "_instructions":
             instructions = value
@@ -231,6 +231,8 @@ class QuestionNameDescriptor(BaseDescriptor):
 
     def validate(self, value, instance):
         """Validate the value is a valid variable name."""
+        from edsl.utilities.utilities import is_valid_variable_name
+
         if not is_valid_variable_name(value):
             raise QuestionCreationValidationError(
                 f"`question_name` is not a valid variable name (got {value})."