edsl 0.1.38.dev4__py3-none-any.whl → 0.1.39__py3-none-any.whl

edsl/language_models/key_management/KeyLookupCollection.py

@@ -0,0 +1,38 @@
+from collections import UserDict
+
+from edsl.language_models.key_management.KeyLookupBuilder import KeyLookupBuilder
+
+
+class KeyLookupCollection(UserDict):
+    """A singleton class that stores key-lookup objects.
+
+    This is because once a KeyLook is created once, we do not
+    need to keep re-creating it.
+
+    >>> collection = KeyLookupCollection()
+    >>> collection2 = KeyLookupCollection()
+    >>> collection is collection2  # Test singleton pattern
+    True
+    >>> collection.add_key_lookup(("config", "env"))
+    >>> ("config", "env") in collection.data
+    True
+    """
+
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, *args, **kwargs):
+        if not hasattr(self, "_initialized"):
+            self.data = {}
+            self._initialized = True
+            super().__init__(*args, **kwargs)
+
+    def add_key_lookup(self, fetch_order=None):
+        if fetch_order is None:
+            fetch_order = ("config", "env")
+        if fetch_order not in self.data:
+            self.data[fetch_order] = KeyLookupBuilder(fetch_order=fetch_order).build()

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/model.py

@@ -0,0 +1,256 @@
+import textwrap
+from random import random
+from typing import Optional, TYPE_CHECKING, List
+
+from edsl.utilities.PrettyList import PrettyList
+from edsl.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
+
+if TYPE_CHECKING:
+    from edsl.results.Dataset import Dataset
+
+
+def get_model_class(model_name, registry: Optional[InferenceServicesCollection] = 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")
+    _registry: InferenceServicesCollection = None  # Class-level registry storage
+
+    @classmethod
+    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
+
+    @classmethod
+    def set_registry(cls, registry: InferenceServicesCollection) -> None:
+        """Set a new registry"""
+        cls._registry = registry
+
+    def __new__(
+        cls,
+        model_name: Optional[str] = None,
+        service_name: Optional[InferenceServiceLiteral] = None,
+        registry: Optional[InferenceServicesCollection] = None,
+        *args,
+        **kwargs,
+    ):
+        "Instantiate a new language model."
+        # 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
+
+        if registry is not None:
+            cls.set_registry(registry)
+
+        if isinstance(model_name, int):  # can refer to a model by index
+            model_name = cls.available(name_only=True)[model_name]
+
+        factory = cls.get_registry().create_model_factory(
+            model_name, service_name=service_name
+        )
+        return factory(*args, **kwargs)
+
+    @classmethod
+    def add_model(cls, service_name, model_name) -> None:
+        cls.get_registry().add_model(service_name, model_name)
+
+    @classmethod
+    def service_classes(cls) -> List["InferenceServiceABC"]:
+        """Returns a list of service classes.
+
+        >>> Model.service_classes()
+        [...]
+        """
+        return [r for r in cls.services(name_only=True)]
+
+    @classmethod
+    def services(cls, name_only: bool = False) -> List[str]:
+        """Returns a list of services, annotated with whether the user has local keys for them."""
+        services_with_local_keys = set(cls.key_info().select("service").to_list())
+        f = lambda service_name: (
+            "yes" if service_name in services_with_local_keys else " "
+        )
+        if name_only:
+            return PrettyList(
+                [r._inference_service_ for r in cls.get_registry().services],
+                columns=["Service Name"],
+            )
+        else:
+            return PrettyList(
+                [
+                    (r._inference_service_, f(r._inference_service_))
+                    for r in cls.get_registry().services
+                ],
+                columns=["Service Name", "Local key?"],
+            )
+
+    @classmethod
+    def services_with_local_keys(cls) -> set:
+        """Returns a list of services for which the user has local keys."""
+        return set(cls.key_info().select("service").to_list())
+
+    @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
+
+        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()))
+        if obscure_api_key:
+            for service in sl:
+                service["api_token"] = (
+                    service["api_token"][:4] + "..." + service["api_token"][-4:]
+                )
+        return sl.to_dataset()
+
+    @classmethod
+    def search_models(cls, search_term: str):
+        return cls.available(search_term=search_term)
+
+    @classmethod
+    def all_known_models(cls) -> "AvailableModels":
+        return cls.get_registry().available()
+
+    @classmethod
+    def available_with_local_keys(cls):
+        services_with_local_keys = set(cls.key_info().select("service").to_list())
+        return [
+            m
+            for m in cls.get_registry().available()
+            if m.service_name in services_with_local_keys
+        ]
+
+    @classmethod
+    def available(
+        cls,
+        search_term: str = None,
+        name_only: bool = False,
+        service: Optional[str] = None,
+    ):
+        # if search_term is None and service is None:
+        #     print("Getting available models...")
+        #     print("You have local keys for the following services:")
+        #     print(cls.services_with_local_keys())
+        #     print("\n")
+        #     print("To see models by service, use the 'service' parameter.")
+        #     print("E.g., Model.available(service='openai')")
+        #     return None
+
+        if service is not None:
+            if service not in cls.services(name_only=True):
+                raise ValueError(
+                    f"Service {service} not found in available services.",
+                    f"Available services are: {cls.services()}",
+                )
+
+        full_list = cls.get_registry().available(service=service)
+
+        if search_term is None:
+            if name_only:
+                return PrettyList(
+                    [m.model_name for m in full_list],
+                    columns=["Model Name"],
+                )
+            else:
+                return PrettyList(
+                    [[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.model_name or search_term in m.service_name
+            ]
+            if name_only:
+                return PrettyList(
+                    [m.model_name for m in filtered_results],
+                    columns=["Model Name"],
+                )
+            else:
+                return PrettyList(
+                    [[m.model_name, m.service_name] for m in full_list],
+                    columns=["Model Name", "Service Name"],
+                )
+
+    @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 import Model
+    from edsl.language_models.model 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")