edsl 0.1.47__py3-none-any.whl → 0.1.49__py3-none-any.whl

edsl/language_models/model.py

@@ -2,19 +2,16 @@ import textwrap
 from random import random
 from typing import Optional, TYPE_CHECKING, List, Callable
 
-from edsl.utilities.PrettyList import PrettyList
-from edsl.config import CONFIG
+from ..utilities import PrettyList
+from ..config import CONFIG
 
-from edsl.inference_services.InferenceServicesCollection import (
-    InferenceServicesCollection,
-)
-from edsl.inference_services.data_structures import AvailableModels
-from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
-from edsl.enums import InferenceServiceLiteral
-from edsl.exceptions.inference_services import InferenceServiceError
+from ..inference_services import (InferenceServicesCollection, 
+                                  AvailableModels, InferenceServiceABC, InferenceServiceError, default)
+
+from ..enums import InferenceServiceLiteral
 
 if TYPE_CHECKING:
-    from edsl.results.Dataset import Dataset
+    from ..dataset import Dataset
 
 
 def get_model_class(
@@ -22,8 +19,6 @@ def get_model_class(
     registry: Optional[InferenceServicesCollection] = None,
     service_name: Optional[InferenceServiceLiteral] = None,
 ):
-    from edsl.inference_services.registry import default
-
     registry = registry or default
     try:
         factory = registry.create_model_factory(model_name, service_name=service_name)
@@ -31,7 +26,6 @@ def get_model_class(
     except (InferenceServiceError, Exception) as e:
         return Model._handle_model_error(model_name, e)
 
-
 class Meta(type):
     def __repr__(cls):
         return textwrap.dedent(
@@ -59,8 +53,6 @@ class Model(metaclass=Meta):
     def get_registry(cls) -> InferenceServicesCollection:
         """Get the current registry or initialize with default if None"""
         if cls._registry is None:
-            from edsl.inference_services.registry import default
-
             cls._registry = default
         return cls._registry
 
@@ -165,10 +157,8 @@ class Model(metaclass=Meta):
     @classmethod
     def key_info(cls, obscure_api_key: bool = True) -> "Dataset":
         """Returns a dataset of local key information."""
-        from edsl.language_models.key_management.KeyLookupCollection import (
-            KeyLookupCollection,
-        )
-        from edsl.scenarios import Scenario, ScenarioList
+        from ..key_management import KeyLookupCollection
+        from ..scenarios import Scenario, ScenarioList
 
         klc = KeyLookupCollection()
         klc.add_key_lookup(fetch_order=None)
@@ -290,7 +280,7 @@ class Model(metaclass=Meta):
         works_with_text: Optional[bool] = None,
         works_with_images: Optional[bool] = None,
     ) -> list[dict]:
-        from edsl.coop import Coop
+        from ..coop import Coop
 
         c = Coop()
         working_models = c.fetch_working_models()
@@ -349,10 +339,5 @@ class Model(metaclass=Meta):
 
 if __name__ == "__main__":
     import doctest
-
     doctest.testmod(optionflags=doctest.ELLIPSIS)
 
-    # available = Model.available()
-    # m = Model("gpt-4-1106-preview")
-    # results = m.execute_model_call("Hello world")
-    # print(results)

edsl/language_models/{ModelList.py → model_list.py}

@@ -1,17 +1,14 @@
 from typing import Optional, List, TYPE_CHECKING
 from collections import UserList
 
-from edsl.Base import Base
-from edsl.language_models.model import Model
+from ..base import Base
+from ..language_models import Model
 
-#
-from edsl.utilities.remove_edsl_version import remove_edsl_version
-from edsl.utilities.is_valid_variable_name import is_valid_variable_name
+from ..utilities import remove_edsl_version, is_valid_variable_name, dict_hash
 
 if TYPE_CHECKING:
-    from edsl.inference_services.data_structures import AvailableModels
-    from edsl.language_models import LanguageModel
-
+    from ..inference_services.data_structures import AvailableModels
+    from ..language_models import LanguageModel
 
 class ModelList(Base, UserList):
     __documentation__ = """https://docs.expectedparrot.com/en/latest/language_models.html#module-edsl.language_models.ModelList"""
@@ -50,13 +47,11 @@ class ModelList(Base, UserList):
         True
 
         """
-        from edsl.utilities.utilities import dict_hash
-
         return dict_hash(self.to_dict(sort=True, add_edsl_version=False))
 
     def to_scenario_list(self):
-        from edsl.scenarios.ScenarioList import ScenarioList
-        from edsl.scenarios.Scenario import Scenario
+        from ..scenarios import ScenarioList
+        from ..scenarios import Scenario
 
         sl = ScenarioList()
         for model in self:
@@ -107,7 +102,7 @@ class ModelList(Base, UserList):
                 ]
             }
         if add_edsl_version:
-            from edsl import __version__
+            from .. import __version__
 
             d["edsl_version"] = __version__
             d["edsl_class_name"] = "ModelList"
@@ -140,7 +135,7 @@ class ModelList(Base, UserList):
         >>> newm = ModelList.from_dict(ModelList.example().to_dict())
         >>> assert ModelList.example() == newm
         """
-        from edsl.language_models.LanguageModel import LanguageModel
+        from ..language_models import LanguageModel
 
         return cls(data=[LanguageModel.from_dict(model) for model in data["models"]])
 

edsl/language_models/{RawResponseHandler.py → raw_response_handler.py}

@@ -1,6 +1,6 @@
 import json
 from typing import Optional, Any, List
-from edsl.exceptions.language_models import LanguageModelBadResponseError
+from .exceptions import LanguageModelBadResponseError
 
 from json_repair import repair_json
 

edsl/language_models/{RegisterLanguageModelsMeta.py → registry.py}

@@ -2,7 +2,7 @@ from abc import ABC, ABCMeta
 from typing import Any, List, Callable
 import inspect
 from typing import get_type_hints
-from edsl.exceptions.language_models import LanguageModelAttributeTypeError
+from .exceptions import LanguageModelAttributeTypeError
 from edsl.enums import InferenceServiceType
 
 

edsl/language_models/repair.py

@@ -6,7 +6,7 @@ import warnings
 async def async_repair(
     bad_json, error_message="", user_prompt=None, system_prompt=None, cache=None
 ):
-    from edsl.utilities.utilities import clean_json
+    from ..utilities import clean_json
 
     s = clean_json(bad_json)
 
@@ -22,7 +22,7 @@ async def async_repair(
         return valid_dict, success
 
     try:
-        from edsl.utilities.repair_functions import extract_json_from_string
+        from ..utilities.repair_functions import extract_json_from_string
 
         valid_dict = extract_json_from_string(s)
         success = True
@@ -32,11 +32,11 @@ async def async_repair(
     else:
         return valid_dict, success
 
-    from edsl.language_models.model import Model
+    from .model import Model
 
     m = Model()
 
-    from edsl.questions.QuestionExtract import QuestionExtract
+    from ..questions.QuestionExtract import QuestionExtract
 
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", UserWarning)

edsl/language_models/utilities.py

@@ -1,11 +1,12 @@
 import asyncio
 from typing import Any, Optional, List
-from edsl.enums import InferenceServiceType
+from ..enums import InferenceServiceType
+from ..surveys import Survey
 
+from .language_model import LanguageModel
 
 def create_survey(num_questions: int, chained: bool = True, take_scenario=False):
-    from edsl.surveys.Survey import Survey
-    from edsl.questions.QuestionFreeText import QuestionFreeText
+    from ..questions import QuestionFreeText
 
     survey = Survey()
     for i in range(num_questions):
@@ -27,7 +28,6 @@ def create_survey(num_questions: int, chained: bool = True, take_scenario=False)
 def create_language_model(
     exception: Exception, fail_at_number: int, never_ending=False
 ):
-    from edsl.language_models.LanguageModel import LanguageModel
 
     class LanguageModelFromUtilities(LanguageModel):
         _model_ = "test"

edsl/notebooks/__init__.py

@@ -1 +1,3 @@
-from edsl.notebooks.Notebook import Notebook
+from .notebook import Notebook
+
+__all__ = ["Notebook"]

edsl/notebooks/{Notebook.py → notebook.py}

@@ -4,9 +4,9 @@ from __future__ import annotations
 import json
 from typing import Dict, List, Optional, Union
 from uuid import uuid4
-from edsl.Base import Base
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
+from ..base import Base
+from ..utilities.decorators import remove_edsl_version
 
 class Notebook(Base):
     """
@@ -102,7 +102,7 @@ class Notebook(Base):
         """
         Allow the model to be used as a key in a dictionary.
         """
-        from edsl.utilities.utilities import dict_hash
+        from ..utilities.utilities import dict_hash
 
         return dict_hash(self.data["cells"])
 
@@ -112,7 +112,7 @@ class Notebook(Base):
         """
         d = {"name": self.name, "data": self.data}
         if add_edsl_version:
-            from edsl import __version__
+            from .. import __version__
 
             d["edsl_version"] = __version__
             d["edsl_class_name"] = self.__class__.__name__
@@ -241,7 +241,7 @@ class Notebook(Base):
         Return the code that could be used to create this Notebook.
         """
         lines = []
-        lines.append("from edsl import Notebook")
+        lines.append("from edsl import Notebook")  # Keep as absolute for code generation
         lines.append(f'nb = Notebook(data={self.data}, name="""{self.name}""")')
         return lines
 
@@ -251,13 +251,12 @@ class Notebook(Base):
 
         :param filename: Name of the output folder and main tex file (without extension)
         """
-        from edsl.notebooks.NotebookToLaTeX import NotebookToLaTeX
+        from .NotebookToLaTeX import NotebookToLaTeX
 
         NotebookToLaTeX(self).convert(filename)
 
 
 if __name__ == "__main__":
-    from edsl import Notebook
-
+    from .. import Notebook
     notebook = Notebook.example()
     assert notebook == notebook.from_dict(notebook.to_dict())

edsl/prompts/__init__.py

@@ -1,2 +1,2 @@
 # from edsl.prompts.registry import get_classes
-from edsl.prompts.Prompt import Prompt
+from .prompt import Prompt

edsl/{exceptions/prompts.py → prompts/exceptions.py}

@@ -1,4 +1,6 @@
-class PromptError(Exception):
+from ..base import BaseException
+
+class PromptError(BaseException):
     pass
 
 

edsl/prompts/{Prompt.py → prompt.py}

@@ -1,33 +1,50 @@
 from __future__ import annotations
 from typing import Any, List, Union, Dict, Optional
 from pathlib import Path
+import time
+from functools import lru_cache
 
-# from jinja2 import Undefined
-
+from jinja2 import Environment, meta, Undefined
 
-from edsl.exceptions.prompts import TemplateRenderError
-from edsl.Base import PersistenceMixin, RepresentationMixin
+from .exceptions import TemplateRenderError
+from ..base import PersistenceMixin, RepresentationMixin
 
 MAX_NESTING = 100
 
-from jinja2 import Environment, meta, TemplateSyntaxError, Undefined
-from functools import lru_cache
-
 class PreserveUndefined(Undefined):
     def __str__(self):
         return "{{ " + str(self._undefined_name) + " }}"
 
-# Create environment once at module level
-_env = Environment(undefined=PreserveUndefined)
+class TemplateVars:
+    """Stores variables set during template rendering."""
+    def __init__(self):
+        self.data = {}
+    
+    def set(self, name, value):
+        """Store a variable with its name and value,
+        returning an empty string for direct use in the template.
+        """
+        self.data[name] = value
+        return ""
+    
+    def get(self, name, default=None):
+        """Retrieve a stored variable."""
+        return self.data.get(name, default)
+    
+    def get_all(self) -> Dict[str, Any]:
+        """Return all captured variables."""
+        return self.data
 
-@lru_cache(maxsize=1024)
-def _compile_template(text: str):
-    return _env.from_string(text)
+def make_env() -> Environment:
+    """Create a fresh Jinja environment each time,
+    so we don't mix captured variables across multiple renders.
+    """
+    return Environment(undefined=PreserveUndefined)
 
 @lru_cache(maxsize=1024)
-def _find_template_variables(template: str) -> list[str]:
-    """Find and return the template variables."""
-    ast = _env.parse(template)
+def _find_template_variables(template_text: str) -> List[str]:
+    env = make_env()
+    ast = env.parse(template_text)
     return list(meta.find_undeclared_variables(ast))
 
 def _make_hashable(value):
@@ -81,9 +98,10 @@ class Prompt(PersistenceMixin, RepresentationMixin):
             # make it idempotent w/ a prompt
             text = text.text
         self._text = text
+        self.captured_variables = {}
 
     @classmethod
-    def from_txt(cls, filename: str) -> PromptBase:
+    def from_txt(cls, filename: str) -> 'Prompt':
         """Create a `Prompt` from text.
 
         :param text: The text of the prompt.
@@ -98,7 +116,7 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         file_name: str,
         path_to_folder: Optional[Union[str, Path]] = None,
         **kwargs: Dict[str, Any],
-    ) -> "PromptBase":
+    ) -> "Prompt":
         """Create a `PromptBase` from a Jinja template.
 
         Args:
@@ -131,11 +149,11 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         return cls(text=text)
 
     @property
-    def text(self):
+    def text(self) -> str:
         """Return the `Prompt` text."""
         return self._text
 
-    def __add__(self, other_prompt):
+    def __add__(self, other_prompt) -> 'Prompt':
         """Add two prompts together.
 
         Example:
@@ -163,7 +181,7 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         """
         return self.text
 
-    def __contains__(self, text_to_check):
+    def __contains__(self, text_to_check) -> bool:
         """Check if the text_to_check is in the `Prompt` text.
 
         Example:
@@ -190,7 +208,7 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         """Return the variables in the template."""
         return _find_template_variables(self.text)
 
-    def undefined_template_variables(self, replacement_dict: dict):
+    def undefined_template_variables(self, replacement_dict: dict) -> list[str]:
         """Return the variables in the template that are not in the replacement_dict.
 
         :param replacement_dict: A dictionary of replacements to populate the template.
@@ -207,7 +225,7 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         """
         return [var for var in self.template_variables() if var not in replacement_dict]
 
-    def unused_traits(self, traits: dict):
+    def unused_traits(self, traits: dict) -> list[str]:
         """Return the traits that are not used in the template."""
         return [trait for trait in traits if trait not in self.template_variables()]
 
@@ -227,8 +245,9 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         """
         return len(self.template_variables()) > 0
 
-    def render(self, primary_replacement: dict, **additional_replacements) -> str:
-        """Render the prompt with the replacements.
+    def render(self, primary_replacement: dict, **additional_replacements) -> "Prompt":
+        """
+        Render the prompt with the replacements.
 
         :param primary_replacement: The primary replacement dictionary.
         :param additional_replacements: Additional replacement dictionaries.
@@ -245,57 +264,65 @@ class Prompt(PersistenceMixin, RepresentationMixin):
 
         >>> p.render({"person": "Mr. {{last_name}}"})
         Prompt(text=\"""Hello, Mr. {{ last_name }}\""")
+
+        >>> p = Prompt("The sum is {% set x = 2 + 3 %}{{ vars.set('x', x) }}{{x}}")
+        >>> result = p.render({})
+        >>> print(result.captured_variables)
+        {'x': 5}
+        >>> result.captured_variables['x']
+        5
         """
         try:
-            new_text = self._render(
-                self.text, primary_replacement, **additional_replacements
+            template_vars = TemplateVars()
+            new_text, captured_vars = self._render(
+                self.text, primary_replacement, template_vars, **additional_replacements
             )
-            return self.__class__(text=new_text)
+            result = Prompt(text=new_text)
+            result.captured_variables = captured_vars
+            return result
         except Exception as e:
             print(f"Error rendering prompt: {e}")
             return self
 
     @staticmethod
-    def _render(text: str, primary_replacement, **additional_replacements) -> "PromptBase":
-        """Render the template text with variables replaced."""
-        import time
-        
-        # if there are no replacements, return the text
-        if not primary_replacement and not additional_replacements:
-            return text
-     
-        try:
-            variables = _find_template_variables(text)
-            
-            if not variables: # if there are no variables, return the text
-                return text
-            
-            # Combine all replacements
-            all_replacements = {**primary_replacement, **additional_replacements}
-            
-            previous_text = None
-            current_text = text
-            iteration = 0
-            
-            for _ in range(MAX_NESTING):
-                iteration += 1
-                
-                template = _compile_template(current_text)
-                rendered_text = template.render(all_replacements)
-                
-                if rendered_text == current_text:
-                    return rendered_text
-                    
-                previous_text = current_text
-                current_text = rendered_text
-
-            raise TemplateRenderError(
-                "Too much nesting - you created an infinite loop here, pal"
-            )
-        except TemplateSyntaxError as e:
-            raise TemplateRenderError(
-                f"Template syntax error: {e}. Bad template: {text}"
-            )
+    def _render(
+        text: str,
+        primary_replacement: dict,
+        template_vars: TemplateVars,
+        **additional_replacements
+    ) -> tuple[str, Dict[str, Any]]:
+        """
+        Render the template text with variables replaced.
+        Returns (rendered_text, captured_variables).
+        """
+        # Combine replacements.
+        all_replacements = {**primary_replacement, **additional_replacements}
+
+        # If no replacements and no Jinja variables, just return the text.
+        if not all_replacements and not _find_template_variables(text):
+            return text, template_vars.get_all()
+
+        env = make_env()
+        # Provide access to the 'vars' object inside the template.
+        env.globals['vars'] = template_vars
+
+        previous_text = None
+        current_text = text
+
+        for _ in range(MAX_NESTING):
+            template = env.from_string(current_text)
+            rendered_text = template.render(**all_replacements)
+
+            if rendered_text == current_text:
+                # No more changes, return final text with captured variables.
+                return rendered_text, template_vars.get_all()
+
+            previous_text = current_text
+            current_text = rendered_text
+
+        raise TemplateRenderError(
+            "Too much nesting - you created an infinite loop here, pal"
+        )
 
     def to_dict(self, add_edsl_version=False) -> dict[str, Any]:
         """Return the `Prompt` as a dictionary.
@@ -310,7 +337,7 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         return {"text": self.text, "class_name": self.__class__.__name__}
 
     @classmethod
-    def from_dict(cls, data) -> PromptBase:
+    def from_dict(cls, data) -> 'Prompt':
         """Create a `Prompt` from a dictionary.
 
         Example:
@@ -324,18 +351,6 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         # class_name = data["class_name"]
         return Prompt(text=data["text"])
 
-    # def rich_print(self):
-    #     """Display an object as a table."""
-    #     table = Table(title="Prompt")
-    #     table.add_column("Attribute", style="bold")
-    #     table.add_column("Value")
-
-    #     to_display = self.__dict__.copy()
-    #     for attr_name, attr_value in to_display.items():
-    #         table.add_row(attr_name, repr(attr_value))
-    #     table.add_row("Component type", str(self.component_type))
-    #     table.add_row("Model", str(getattr(self, "model", "Not specified")))
-    #     return table
 
     @classmethod
     def example(cls):
@@ -343,7 +358,12 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         return cls(cls.default_instructions)
 
     def get_prompts(self) -> Dict[str, Any]:
-        """Get the prompts for the question."""
+        """Get the prompts for the question.        
+
+        >>> p = Prompt("Hello, {{person}}")
+        """
+
+        raise NotImplementedError("This method should be implemented by the subclass.")
         start = time.time()
         
         # Build all the components
@@ -396,20 +416,6 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         return prompts
 
 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 *
-
-# from edsl.prompts.library.question_budget import *
-# from edsl.prompts.library.question_checkbox import *
-# from edsl.prompts.library.question_freetext import *
-# from edsl.prompts.library.question_linear_scale import *
-# 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 *

edsl/questions/HTMLQuestion.py

@@ -1,5 +1,5 @@
 from typing import Optional
-from edsl.prompts.Prompt import Prompt
+from ..prompts import Prompt
 
 
 class HTMLQuestion: