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

edsl/language_models/key_management/models.py

@@ -0,0 +1,131 @@
+from dataclasses import dataclass, asdict
+from typing import Optional
+
+
+@dataclass
+class APIKeyEntry:
+    """A class representing an API key entry.
+
+    >>> entry = APIKeyEntry.example()
+    >>> entry.service
+    'openai'
+    >>> entry.name
+    'OPENAI_API_KEY'
+    >>> entry.value
+    'sk-abcd1234'
+    >>> entry.source
+    'env'
+    """
+
+    service: str
+    name: str
+    value: str
+    source: Optional[str] = None
+
+    @classmethod
+    def example(cls):
+        return APIKeyEntry(
+            service="openai", name="OPENAI_API_KEY", value="sk-abcd1234", source="env"
+        )
+
+
+@dataclass
+class LimitEntry:
+    """A class representing rate limit entries for a service.
+
+    >>> limit = LimitEntry.example()
+    >>> limit.service
+    'openai'
+    >>> limit.rpm
+    60
+    >>> limit.tpm
+    100000
+    >>> limit.source
+    'config'
+    """
+
+    service: str
+    rpm: int
+    tpm: int
+    source: Optional[str] = None
+
+    @classmethod
+    def example(cls):
+        return LimitEntry(service="openai", rpm=60, tpm=100000, source="config")
+
+
+@dataclass
+class APIIDEntry:
+    """A class representing an API ID entry.
+
+    >>> id_entry = APIIDEntry.example()
+    >>> id_entry.service
+    'bedrock'
+    >>> id_entry.name
+    'AWS_ACCESS_KEY_ID'
+    >>> id_entry.value
+    'AKIA1234'
+    >>> id_entry.source
+    'env'
+    """
+
+    service: str
+    name: str
+    value: str
+    source: Optional[str] = None
+
+    @classmethod
+    def example(cls):
+        return APIIDEntry(
+            service="bedrock", name="AWS_ACCESS_KEY_ID", value="AKIA1234", source="env"
+        )
+
+
+@dataclass
+class LanguageModelInput:
+    """A class representing input configuration for a language model service.
+
+    >>> lm_input = LanguageModelInput.example()
+    >>> lm_input.api_token
+    'sk-abcd123'
+    >>> lm_input.rpm
+    60
+    >>> lm_input.tpm
+    100000
+    >>> lm_input.api_id
+
+
+    Test dictionary conversion:
+    >>> d = lm_input.to_dict()
+    >>> isinstance(d, dict)
+    True
+    >>> LanguageModelInput.from_dict(d).api_token == lm_input.api_token
+    True
+    """
+
+    api_token: str
+    rpm: int
+    tpm: int
+    api_id: Optional[str] = None
+    token_source: Optional[str] = None
+    limit_source: Optional[str] = None
+    id_source: Optional[str] = None
+
+    def to_dict(self):
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, d):
+        return cls(**d)
+
+    @classmethod
+    def example(cls):
+        return LanguageModelInput(
+            api_token="sk-abcd123", tpm=100000, rpm=60, api_id=None
+        )
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

edsl/language_models/registry.py

@@ -1,54 +1,9 @@
 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>"
-            )
+from functools import lru_cache
+from edsl.utilities.PrettyList import PrettyList
+from typing import Optional
 
 
 def get_model_class(model_name, registry=None):
@@ -103,48 +58,83 @@ class Model(metaclass=Meta):
         registry = default
         registry.add_model(service_name, model_name)
 
+    @classmethod
+    def service_classes(cls, registry=None):
+        from edsl.inference_services.registry import default
+
+        registry = registry or default
+        return [r for r in registry.services]
+
     @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]
+        return PrettyList(
+            [r._inference_service_ for r in registry.services], columns=["Service Name"]
+        )
 
     @classmethod
-    def available(cls, search_term=None, name_only=False, registry=None, service=None):
+    def key_info(cls):
+        from edsl.language_models.key_management import KeyLookupCollection
+        from edsl.scenarios import Scenario, ScenarioList
+
+        klc = KeyLookupCollection()
+        klc.add_key_lookup(fetch_order=None)
+        sl = ScenarioList()
+        for service, entry in list(klc.data.values())[0].items():
+            sl.append(Scenario({"service": service} | entry.to_dict()))
+        return sl.to_dataset()
+
+    @classmethod
+    def available(
+        cls,
+        search_term: str = None,
+        name_only: bool = False,
+        registry=None,
+        service: Optional[str] = None,
+    ):
         from edsl.inference_services.registry import default
 
         registry = registry or default
-        full_list = registry.available()
+        # 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]
+        # import time
+        # start = time.time()
+        full_list = registry.available(service=service)
+        # end = time.time()
+        # print(f"Time taken to get available models: {end-start}")
 
         if search_term is None:
             if name_only:
                 return PrettyList(
-                    [m[0] for m in full_list],
-                    columns=["Model Name", "Service Name", "Code"],
+                    [m.model_name for m in full_list],
+                    columns=["Model Name"],
                 )
             else:
                 return PrettyList(
-                    full_list, columns=["Model Name", "Service Name", "Code"]
+                    [[m.model_name, m.service_name] for m in full_list],
+                    columns=["Model Name", "Service Name"],
                 )
         else:
             filtered_results = [
-                m for m in full_list if search_term in m[0] or search_term in m[1]
+                m
+                for m in full_list
+                if search_term in m.model_name or search_term in m.service_name
             ]
             if name_only:
                 return PrettyList(
-                    [m[0] for m in filtered_results],
-                    columns=["Model Name", "Service Name", "Code"],
+                    [m.model_name for m in filtered_results],
+                    columns=["Model Name"],
                 )
             else:
                 return PrettyList(
-                    filtered_results, columns=["Model Name", "Service Name", "Code"]
+                    [[m.model_name, m.service_name] for m in full_list],
+                    columns=["Model Name", "Service Name"],
                 )
 
     @classmethod

edsl/language_models/repair.py

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

edsl/language_models/utilities.py

@@ -1,13 +1,12 @@
 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:
@@ -28,6 +27,8 @@ 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,
-        data: Optional[Dict] = None,
         path: Optional[str] = None,
+        data: Optional[Dict] = None,
         name: Optional[str] = None,
     ):
         """
@@ -33,12 +33,16 @@ class Notebook(Base):
         import nbformat
 
         # Load current notebook path as fallback (VS Code only)
-        path = path or globals().get("__vsc_ipynb_file__")
-        if data is not None:
+        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:
             nbformat.validate(data)
             self.data = data
-        elif path is not None:
-            with open(path, mode="r", encoding="utf-8") as f:
+        elif current_notebook_path is not None:
+            with open(current_notebook_path, mode="r", encoding="utf-8") as f:
                 data = nbformat.read(f, as_version=4)
             self.data = json.loads(json.dumps(data))
         else:
@@ -130,15 +134,6 @@ 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.
@@ -250,6 +245,16 @@ 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/notebooks/NotebookToLaTeX.py

@@ -0,0 +1,142 @@
+from typing import Optional, Dict
+import os
+import nbformat
+from nbconvert.exporters import LatexExporter
+from nbconvert.writers import FilesWriter
+
+
+class NotebookToLaTeX:
+    """
+    A class for converting Jupyter notebooks to LaTeX with proper directory structure.
+    """
+
+    def __init__(self, notebook):
+        """
+        Initialize with a Notebook instance.
+
+        :param notebook: An instance of the Notebook class
+        """
+        self.notebook = notebook
+        self.latex_exporter = LatexExporter()
+        self._configure_exporter()
+
+    def _configure_exporter(self):
+        """Configure the LaTeX exporter with default settings."""
+        self.latex_exporter.exclude_input_prompt = True
+        self.latex_exporter.exclude_output_prompt = True
+        self.latex_exporter.template_name = "classic"
+
+    def _create_makefile(self, filename: str, output_dir: str):
+        """Create a Makefile for the LaTeX project."""
+        makefile_content = f"""# Makefile for {filename}
+all: pdf
+
+pdf: {filename}.pdf
+
+{filename}.pdf: {filename}.tex
+\tpdflatex {filename}.tex
+\tpdflatex {filename}.tex  # Run twice for references
+\tbibtex {filename}       # Run bibtex if needed
+\tpdflatex {filename}.tex  # Run one more time for bibtex
+
+clean:
+\trm -f *.aux *.log *.out *.toc *.pdf *.bbl *.blg
+"""
+        makefile_path = os.path.join(output_dir, "Makefile")
+        with open(makefile_path, "w") as f:
+            f.write(makefile_content)
+
+    def _create_readme(self, filename: str, output_dir: str):
+        """Create a README file with usage instructions."""
+        readme_content = f"""# {filename}
+
+This folder contains the LaTeX version of your Jupyter notebook.
+
+Files:
+- {filename}.tex: Main LaTeX file
+- Makefile: Build automation
+
+To compile the PDF:
+1. Make sure you have a LaTeX distribution installed (e.g., TexLive)
+2. Run `make` in this directory
+3. The output will be {filename}.pdf
+
+To clean up build files:
+- Run `make clean`
+"""
+        readme_path = os.path.join(output_dir, "README.md")
+        with open(readme_path, "w") as f:
+            f.write(readme_content)
+
+    def convert(self, filename: str, output_dir: Optional[str] = None):
+        """
+        Convert the notebook to LaTeX and create a project directory.
+
+        :param filename: Name for the output files (without extension)
+        :param output_dir: Optional directory path. If None, uses filename as directory
+        """
+        # Use filename as directory if no output_dir specified
+        output_dir = output_dir or filename
+
+        # Create output directory
+        os.makedirs(output_dir, exist_ok=True)
+
+        # Convert notebook to nbformat
+        notebook_node = nbformat.from_dict(self.notebook.data)
+
+        # Convert to LaTeX
+        body, resources = self.latex_exporter.from_notebook_node(notebook_node)
+
+        # Write the main tex file
+        output_file_path = os.path.join(output_dir, f"{filename}.tex")
+        with open(output_file_path, "w", encoding="utf-8") as f:
+            f.write(body)
+
+        # Write additional resources (images, etc.)
+        if resources.get("outputs"):
+            for fname, data in resources["outputs"].items():
+                resource_path = os.path.join(output_dir, fname)
+                with open(resource_path, "wb") as f:
+                    f.write(data)
+
+        # Create supporting files
+        self._create_makefile(filename, output_dir)
+        self._create_readme(filename, output_dir)
+
+    def set_template(self, template_name: str):
+        """
+        Set the LaTeX template to use.
+
+        :param template_name: Name of the template (e.g., 'classic', 'article')
+        """
+        self.latex_exporter.template_name = template_name
+
+    def set_template_options(self, options: Dict):
+        """
+        Set additional template options.
+
+        :param options: Dictionary of template options
+        """
+        for key, value in options.items():
+            setattr(self.latex_exporter, key, value)
+
+
+# Example usage:
+if __name__ == "__main__":
+    from edsl import Notebook
+
+    # Create or load a notebook
+    notebook = Notebook.example()
+
+    # Create converter and convert
+    converter = NotebookToLaTeX(notebook)
+    converter.convert("example_output")
+
+    # Example with custom template options
+    converter.set_template_options(
+        {
+            "exclude_input": True,  # Hide input cells
+            "exclude_output": False,  # Show output cells
+        }
+    )
+    converter.convert("example_output_custom")

edsl/prompts/Prompt.py

@@ -1,43 +1,21 @@
 from __future__ import annotations
-from typing import Optional
-from abc import ABC
-from typing import Any, List
-
-from jinja2 import Environment, FileSystemLoader
-from typing import Union, Dict
+from typing import Any, List, Union, Dict, Optional
 from pathlib import Path
 
-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 jinja2 import Undefined
 
 
 from edsl.exceptions.prompts import TemplateRenderError
-from edsl.Base import PersistenceMixin, RichPrintingMixin
+from edsl.Base import PersistenceMixin, RepresentationMixin
 
 MAX_NESTING = 100
 
 
-class Prompt(PersistenceMixin, RichPrintingMixin):
+class Prompt(PersistenceMixin, RepresentationMixin):
     """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)
@@ -185,6 +163,12 @@ class Prompt(PersistenceMixin, RichPrintingMixin):
         :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))
@@ -273,6 +257,12 @@ class Prompt(PersistenceMixin, RichPrintingMixin):
         >>> 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
@@ -296,7 +286,7 @@ class Prompt(PersistenceMixin, RichPrintingMixin):
                 f"Template syntax error: {e}. Bad template: {text}"
             )
 
-    def to_dict(self) -> dict[str, Any]:
+    def to_dict(self, add_edsl_version=False) -> dict[str, Any]:
         """Return the `Prompt` as a dictionary.
 
         Example:
@@ -323,18 +313,18 @@ class Prompt(PersistenceMixin, RichPrintingMixin):
         # 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):