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

edsl/language_models/key_management/models.py

@@ -1,131 +0,0 @@
-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

@@ -1,256 +0,0 @@
-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/notebooks/NotebookToLaTeX.py

@@ -1,142 +0,0 @@
-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/questions/ExceptionExplainer.py

@@ -1,77 +0,0 @@
-from pydantic import ValidationError
-from typing import Union
-
-
-class ExceptionExplainer:
-    """
-    A class that converts validation errors into human-readable explanations,
-    specifically for Language Model responses.
-    """
-
-    def __init__(self, error: Union[ValidationError, Exception], model_response: str):
-        """
-        Initialize the explainer with the error and model response.
-
-        Args:
-            error: The validation error that occurred
-            model_response: The raw response from the Language Model
-        """
-        self.error = error
-        self.model_response = model_response
-
-    def explain(self) -> str:
-        """
-        Generate a human-readable explanation of why the model's response failed validation.
-
-        Returns:
-            A user-friendly explanation of why the model's response was invalid
-        """
-        self.error = self.error.pydantic_error
-        return self._explain_validation_error()
-
-        # Fallback for unknown errors
-        return self._create_generic_explanation()
-
-    def _explain_validation_error(self) -> str:
-        """Handle Pydantic ValidationError specifically."""
-        error_dict = self.error.errors()
-        explanations = []
-
-        context = f'The AI model returned "{self.model_response}", but this was invalid for the question you asked and the constraints you provided.\n'
-        explanations.append(context)
-        explanations.append("Reason(s) invalidated:")
-        for e in error_dict:
-            msg = e.get("msg", "Unknown error")
-            explanations.append(f"- {msg}")
-
-        main_message = "\n".join(explanations)
-        return f"{main_message}\n\n{self._get_suggestion()}"
-
-    def _create_generic_explanation(self) -> str:
-        """Create a generic explanation for non-ValidationError exceptions."""
-        return (
-            f'The AI model returned "{self.model_response}", but this response was invalid. '
-            f"Error: {str(self.error)}"
-        )
-
-    def _get_suggestion(self) -> str:
-        """Get a suggestion for handling the error."""
-        return (
-            "EDSL Advice:\n"
-            "- Look at the Model comments - often the model will provide a hint about what went wrong.\n"
-            "- If the model's response doesn't make sense, try rephrasing your question.\n"
-            "- Try using 'use_code' parameter of a MultipleChoice.\n"
-            "- A QuestionFreeText will almost always validate.\n"
-            "- Try setting the 'permissive' = True parameter in the Question constructor."
-        )
-
-
-# Example usage:
-if __name__ == "__main__":
-    try:
-        # Your validation code here
-        raise ValidationError.parse_obj({"answer": "120"})
-    except ValidationError as e:
-        explainer = ExceptionExplainer(e, "120")
-        explanation = explainer.explain()
-        print(explanation)