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

edsl/language_models/ModelList.py

@@ -1,22 +1,18 @@
-from typing import Optional, List, TYPE_CHECKING
+from typing import Optional, List
 from collections import UserList
+from edsl import Model
 
+from edsl.language_models import LanguageModel
 from edsl.Base import Base
-from edsl.language_models.model import Model
-
-#
-from edsl.utilities.remove_edsl_version import remove_edsl_version
-from edsl.utilities.is_valid_variable_name import is_valid_variable_name
-
-if TYPE_CHECKING:
-    from edsl.inference_services.data_structures import AvailableModels
-    from edsl.language_models import LanguageModel
+from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+from edsl.utilities.utilities import is_valid_variable_name
+from edsl.utilities.utilities import dict_hash
 
 
 class ModelList(Base, UserList):
     __documentation__ = """https://docs.expectedparrot.com/en/latest/language_models.html#module-edsl.language_models.ModelList"""
 
-    def __init__(self, data: Optional["LanguageModel"] = None):
+    def __init__(self, data: Optional[list] = None):
         """Initialize the ScenarioList class.
 
         >>> from edsl import Model
@@ -37,11 +33,14 @@ class ModelList(Base, UserList):
         """
         return set([model.model for model in self])
 
+    def rich_print(self):
+        pass
+
     def __repr__(self):
         return f"ModelList({super().__repr__()})"
 
     def _summary(self):
-        return {"models": len(self)}
+        return {"EDSL Class": "ModelList", "Number of Models": len(self)}
 
     def __hash__(self):
         """Return a hash of the ModelList. This is used for comparison of ModelLists.
@@ -55,8 +54,7 @@ class ModelList(Base, UserList):
         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 edsl import ScenarioList, Scenario
 
         sl = ScenarioList()
         for model in self:
@@ -75,7 +73,7 @@ class ModelList(Base, UserList):
         pretty_labels: Optional[dict] = None,
     ):
         """
-        >>> ModelList.example().table('model')
+        >>> ModelList.example().table("model")
         model
         -------
         gpt-4o
@@ -88,7 +86,7 @@ class ModelList(Base, UserList):
             .table(*fields, tablefmt=tablefmt, pretty_labels=pretty_labels)
         )
 
-    def to_list(self) -> list:
+    def to_list(self):
         return self.to_scenario_list().to_list()
 
     def to_dict(self, sort=False, add_edsl_version=True):
@@ -114,6 +112,11 @@ class ModelList(Base, UserList):
 
         return d
 
+    def _repr_html_(self):
+        """Return an HTML representation of the ModelList."""
+        footer = f"<a href={self.__documentation__}>(docs)</a>"
+        return str(self.summary(format="html")) + footer
+
     @classmethod
     def from_names(self, *args, **kwargs):
         """A a model list from a list of names"""
@@ -121,16 +124,6 @@ class ModelList(Base, UserList):
             args = args[0]
         return ModelList([Model(model_name, **kwargs) for model_name in args])
 
-    @classmethod
-    def from_available_models(self, available_models_list: "AvailableModels"):
-        """Create a ModelList from an AvailableModels object"""
-        return ModelList(
-            [
-                Model(model.model_name, service_name=model.service_name)
-                for model in available_models_list
-            ]
-        )
-
     @classmethod
     @remove_edsl_version
     def from_dict(cls, data):
@@ -140,8 +133,6 @@ class ModelList(Base, UserList):
         >>> newm = ModelList.from_dict(ModelList.example().to_dict())
         >>> assert ModelList.example() == newm
         """
-        from edsl.language_models.LanguageModel import LanguageModel
-
         return cls(data=[LanguageModel.from_dict(model) for model in data["models"]])
 
     def code(self):

edsl/language_models/__init__.py

@@ -1,2 +1,3 @@
 from edsl.language_models.LanguageModel import LanguageModel
-from edsl.language_models.model import Model
+from edsl.language_models.registry import Model
+from edsl.language_models.KeyLookup import KeyLookup

edsl/language_models/registry.py

@@ -0,0 +1,190 @@
+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")
+
+from collections import UserList
+
+
+class PrettyList(UserList):
+    def __init__(self, data=None, columns=None):
+        super().__init__(data)
+        self.columns = columns
+
+    def _repr_html_(self):
+        if isinstance(self[0], list) or isinstance(self[0], tuple):
+            num_cols = len(self[0])
+        else:
+            num_cols = 1
+
+        if self.columns:
+            columns = self.columns
+        else:
+            columns = list(range(num_cols))
+
+        if num_cols > 1:
+            return (
+                "<pre><table>"
+                + "".join(["<th>" + str(column) + "</th>" for column in columns])
+                + "".join(
+                    [
+                        "<tr>"
+                        + "".join(["<td>" + str(x) + "</td>" for x in row])
+                        + "</tr>"
+                        for row in self
+                    ]
+                )
+                + "</table></pre>"
+            )
+        else:
+            return (
+                "<pre><table>"
+                + "".join(["<th>" + str(index) + "</th>" for index in columns])
+                + "".join(
+                    ["<tr>" + "<td>" + str(row) + "</td>" + "</tr>" for row in self]
+                )
+                + "</table></pre>"
+            )
+
+
+def get_model_class(model_name, registry=None):
+    from edsl.inference_services.registry import default
+
+    registry = registry or default
+    factory = registry.create_model_factory(model_name)
+    return factory
+
+
+class Meta(type):
+    def __repr__(cls):
+        return textwrap.dedent(
+            f"""\
+        Available models: {cls.available()}
+        
+        To create an instance, you can do: 
+        >>> m = Model('gpt-4-1106-preview', temperature=0.5, ...)
+        
+        To get the default model, you can leave out the model name. 
+        To see the available models, you can do:
+        >>> Model.available()
+        """
+        )
+
+
+class Model(metaclass=Meta):
+    default_model = CONFIG.get("EDSL_DEFAULT_MODEL")
+
+    def __new__(
+        cls, model_name=None, registry=None, service_name=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
+        from edsl.inference_services.registry import default
+
+        registry = registry or default
+
+        if isinstance(model_name, int):  # can refer to a model by index
+            model_name = cls.available(name_only=True)[model_name]
+
+        factory = registry.create_model_factory(model_name, service_name=service_name)
+        return factory(*args, **kwargs)
+
+    @classmethod
+    def add_model(cls, service_name, model_name):
+        from edsl.inference_services.registry import default
+
+        registry = default
+        registry.add_model(service_name, model_name)
+
+    @classmethod
+    def services(cls, registry=None):
+        from edsl.inference_services.registry import default
+
+        registry = registry or default
+        return [r._inference_service_ for r in registry.services]
+
+    @classmethod
+    def available(cls, search_term=None, name_only=False, registry=None, service=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 PrettyList(
+                    [m[0] for m in full_list],
+                    columns=["Model Name", "Service Name", "Code"],
+                )
+            else:
+                return PrettyList(
+                    full_list, columns=["Model Name", "Service Name", "Code"]
+                )
+        else:
+            filtered_results = [
+                m for m in full_list if search_term in m[0] or search_term in m[1]
+            ]
+            if name_only:
+                return PrettyList(
+                    [m[0] for m in filtered_results],
+                    columns=["Model Name", "Service Name", "Code"],
+                )
+            else:
+                return PrettyList(
+                    filtered_results, columns=["Model Name", "Service Name", "Code"]
+                )
+
+    @classmethod
+    def check_models(cls, verbose=False):
+        print("Checking all available models...\n")
+        for model in cls.available(name_only=True):
+            print(f"Now checking: {model}")
+            try:
+                m = cls(model)
+            except Exception as e:
+                print(f"Error creating instance of {model}: {e}")
+                continue
+            try:
+                results = m.hello(verbose)
+                if verbose:
+                    print(f"Results from model call: {results}")
+            except Exception as e:
+                print(f"Error calling 'hello' on {model}: {e}")
+                continue
+            print("OK!")
+            print("\n")
+
+    @classmethod
+    def example(cls, randomize: bool = False) -> "Model":
+        """
+        Returns an example Model instance.
+
+        :param randomize: If True, the temperature is set to a random decimal between 0 and 1.
+        """
+        temperature = 0.5 if not randomize else round(random(), 2)
+        model_name = cls.default_model
+        return cls(model_name, temperature=temperature)
+
+
+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/repair.py

@@ -32,11 +32,11 @@ async def async_repair(
     else:
         return valid_dict, success
 
-    from edsl.language_models.model import Model
+    from edsl import Model
 
     m = Model()
 
-    from edsl.questions.QuestionExtract import QuestionExtract
+    from edsl import QuestionExtract
 
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", UserWarning)

edsl/language_models/unused/ReplicateBase.py

@@ -0,0 +1,83 @@
+import asyncio
+import aiohttp
+import json
+from typing import Any
+
+from edsl import CONFIG
+
+from edsl.language_models.LanguageModel import LanguageModel
+
+
+def replicate_model_factory(model_name, base_url, api_token):
+    class ReplicateLanguageModelBase(LanguageModel):
+        _model_ = (
+            model_name  # Example model name, replace with actual model name if needed
+        )
+        _parameters_ = {
+            "temperature": 0.1,
+            "topK": 50,
+            "topP": 0.9,
+            "max_new_tokens": 500,
+            "min_new_tokens": -1,
+            "repetition_penalty": 1.15,
+            #       "version": "5fe0a3d7ac2852264a25279d1dfb798acbc4d49711d126646594e212cb821749",
+            "use_cache": True,
+        }
+        _api_token = api_token
+        _base_url = base_url
+
+        async def async_execute_model_call(
+            self, user_prompt: str, system_prompt: str = ""
+        ) -> dict[str, Any]:
+            self.api_token = self._api_token
+            self.headers = {
+                "Authorization": f"Token {self.api_token}",
+                "Content-Type": "application/json",
+            }
+            # combined_prompt = f"{system_prompt} {user_prompt}".strip()
+            # print(f"Prompt: {combined_prompt}")
+            data = {
+                #          "version": self._parameters_["version"],
+                "input": {
+                    "debug": False,
+                    "top_k": self._parameters_["topK"],
+                    "top_p": self._parameters_["topP"],
+                    "prompt": user_prompt,
+                    "system_prompt": system_prompt,
+                    "temperature": self._parameters_["temperature"],
+                    "max_new_tokens": self._parameters_["max_new_tokens"],
+                    "min_new_tokens": self._parameters_["min_new_tokens"],
+                    "prompt_template": "{prompt}",
+                    "repetition_penalty": self._parameters_["repetition_penalty"],
+                },
+            }
+
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    self._base_url, headers=self.headers, data=json.dumps(data)
+                ) as response:
+                    raw_response_text = await response.text()
+                    data = json.loads(raw_response_text)
+                    print(f"This was the data returned by the model:{data}")
+                    prediction_url = data["urls"]["get"]
+
+                while True:
+                    async with session.get(
+                        prediction_url, headers=self.headers
+                    ) as get_response:
+                        if get_response.status != 200:
+                            # Handle non-success status codes appropriately
+                            return None
+
+                        get_data = await get_response.text()
+                        get_data = json.loads(get_data)
+                        if get_data["status"] == "succeeded":
+                            return get_data
+                        await asyncio.sleep(1)
+
+        def parse_response(self, raw_response: dict[str, Any]) -> str:
+            data = "".join(raw_response["output"])
+            print(f"This is what the model returned: {data}")
+            return data
+
+    return ReplicateLanguageModelBase

edsl/language_models/utilities.py

@@ -1,12 +1,13 @@
 import asyncio
 from typing import Any, Optional, List
+from edsl import Survey
+from edsl.config import CONFIG
 from edsl.enums import InferenceServiceType
+from edsl.language_models.LanguageModel import LanguageModel
+from edsl.questions import QuestionFreeText
 
 
 def create_survey(num_questions: int, chained: bool = True, take_scenario=False):
-    from edsl.surveys.Survey import Survey
-    from edsl.questions.QuestionFreeText import QuestionFreeText
-
     survey = Survey()
     for i in range(num_questions):
         if take_scenario:
@@ -27,8 +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"
         _parameters_ = {"temperature": 0.5}

edsl/notebooks/Notebook.py

@@ -17,8 +17,8 @@ class Notebook(Base):
 
     def __init__(
         self,
-        path: Optional[str] = None,
         data: Optional[Dict] = None,
+        path: Optional[str] = None,
         name: Optional[str] = None,
     ):
         """
@@ -33,16 +33,12 @@ class Notebook(Base):
         import nbformat
 
         # Load current notebook path as fallback (VS Code only)
-        current_notebook_path = globals().get("__vsc_ipynb_file__")
-        if path is not None:
-            with open(path, mode="r", encoding="utf-8") as f:
-                data = nbformat.read(f, as_version=4)
-            self.data = json.loads(json.dumps(data))
-        elif data is not None:
+        path = path or globals().get("__vsc_ipynb_file__")
+        if data is not None:
             nbformat.validate(data)
             self.data = data
-        elif current_notebook_path is not None:
-            with open(current_notebook_path, mode="r", encoding="utf-8") as f:
+        elif path is not None:
+            with open(path, mode="r", encoding="utf-8") as f:
                 data = nbformat.read(f, as_version=4)
             self.data = json.loads(json.dumps(data))
         else:
@@ -134,6 +130,15 @@ class Notebook(Base):
 
         nbformat.write(nbformat.from_dict(self.data), fp=path)
 
+    def print(self):
+        """
+        Print the notebook.
+        """
+        from rich import print_json
+        import json
+
+        print_json(json.dumps(self.to_dict()))
+
     def __repr__(self):
         """
         Return representation of Notebook.
@@ -245,16 +250,6 @@ class Notebook(Base):
         lines.append(f'nb = Notebook(data={self.data}, name="""{self.name}""")')
         return lines
 
-    def to_latex(self, filename: str):
-        """
-        Convert notebook to LaTeX and create a folder with all necessary components.
-
-        :param filename: Name of the output folder and main tex file (without extension)
-        """
-        from edsl.notebooks.NotebookToLaTeX import NotebookToLaTeX
-
-        NotebookToLaTeX(self).convert(filename)
-
 
 if __name__ == "__main__":
     from edsl import Notebook

edsl/prompts/Prompt.py

@@ -1,21 +1,43 @@
 from __future__ import annotations
-from typing import Any, List, Union, Dict, Optional
+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 jinja2 import Undefined
+from rich.table import Table
+from jinja2 import Template, Environment, meta, TemplateSyntaxError, Undefined
+
+
+class PreserveUndefined(Undefined):
+    def __str__(self):
+        return "{{ " + str(self._undefined_name) + " }}"
 
 
 from edsl.exceptions.prompts import TemplateRenderError
-from edsl.Base import PersistenceMixin, RepresentationMixin
+from edsl.Base import PersistenceMixin, RichPrintingMixin
 
 MAX_NESTING = 100
 
 
-class Prompt(PersistenceMixin, RepresentationMixin):
+class Prompt(PersistenceMixin, RichPrintingMixin):
     """Class for creating a prompt to be used in a survey."""
 
     default_instructions: Optional[str] = "Do good things, friendly LLM!"
 
+    def _repr_html_(self):
+        """Return an HTML representation of the Prompt."""
+        # from edsl.utilities.utilities import data_to_html
+        # return data_to_html(self.to_dict())
+        d = self.to_dict()
+        data = [[k, v] for k, v in d.items()]
+        from tabulate import tabulate
+
+        table = str(tabulate(data, headers=["keys", "values"], tablefmt="html"))
+        return f"<pre>{table}</pre>"
+
     def __len__(self):
         """Return the length of the prompt text."""
         return len(self.text)
@@ -163,12 +185,6 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         :param template: The template to find the variables in.
 
         """
-        from jinja2 import Environment, meta, Undefined
-
-        class PreserveUndefined(Undefined):
-            def __str__(self):
-                return "{{ " + str(self._undefined_name) + " }}"
-
         env = Environment(undefined=PreserveUndefined)
         ast = env.parse(template)
         return list(meta.find_undeclared_variables(ast))
@@ -257,12 +273,6 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         >>> p.render({"name": "John", "age": 44}, codebook=codebook)
         Prompt(text=\"""You are an agent named John. Age: 44\""")
         """
-        from jinja2 import Environment, meta, TemplateSyntaxError, Undefined
-
-        class PreserveUndefined(Undefined):
-            def __str__(self):
-                return "{{ " + str(self._undefined_name) + " }}"
-
         env = Environment(undefined=PreserveUndefined)
         try:
             previous_text = None
@@ -286,7 +296,7 @@ class Prompt(PersistenceMixin, RepresentationMixin):
                 f"Template syntax error: {e}. Bad template: {text}"
             )
 
-    def to_dict(self, add_edsl_version=False) -> dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Return the `Prompt` as a dictionary.
 
         Example:
@@ -313,18 +323,18 @@ 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
+    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):

edsl/questions/{answer_validator_mixin.py → AnswerValidatorMixin.py}

@@ -2,7 +2,7 @@
 
 import re
 from typing import Any, Type, Union
-from edsl.exceptions.questions import (
+from edsl.exceptions import (
     QuestionAnswerValidationError,
 )
 
@@ -213,12 +213,7 @@ class AnswerValidatorMixin:
         - is not less than `min_value`
         - is not greater than `max_value`
         """
-        try:
-            value = float(answer.get("answer"))
-        except ValueError:
-            raise QuestionAnswerValidationError(
-                f"Answer must real number or convertible to a real number (got {answer.get('answer')})."
-            )
+        value = float(answer.get("answer"))
         if self.min_value is not None and value < self.min_value:
             raise QuestionAnswerValidationError(
                 f"Value {value} is less than {self.min_value}"
@@ -284,46 +279,6 @@ class AnswerValidatorMixin:
                 f"Rank answer {value}, but exactly {self.num_selections} selections required."
             )
 
-    def _validate_answer_matrix(self, answer: dict[str, Any]) -> None:
-        """Validate QuestionMatrix-specific answer.
-
-        Check that answer["answer"]:
-        - is a dictionary
-        - has all required question_items as keys
-        - has values that are valid options from question_options
-        - has the correct number of responses (one per item)
-        """
-        value = answer.get("answer")
-
-        # Check that answer is a dictionary
-        if not isinstance(value, dict):
-            raise QuestionAnswerValidationError(
-                f"Matrix answer must be a dictionary mapping items to responses (got {value})"
-            )
-
-        # Check that all required items are present
-        required_items = set(self.question_items)
-        provided_items = set(value.keys())
-
-        if missing_items := (required_items - provided_items):
-            raise QuestionAnswerValidationError(
-                f"Missing responses for items: {missing_items}"
-            )
-
-        if extra_items := (provided_items - required_items):
-            raise QuestionAnswerValidationError(
-                f"Unexpected responses for items: {extra_items}"
-            )
-
-        # Check that all responses are valid options
-        valid_options = set(self.question_options)
-        for item, response in value.items():
-            if response not in valid_options:
-                raise QuestionAnswerValidationError(
-                    f"Invalid response '{response}' for item '{item}'. "
-                    f"Must be one of: {valid_options}"
-                )
-
 
 if __name__ == "__main__":
     pass