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

edsl/jobs/data_structures.py

@@ -1,120 +0,0 @@
-from typing import Optional, Literal
-from dataclasses import dataclass, asdict
-
-# from edsl.data_transfer_models import VisibilityType
-from edsl.data.Cache import Cache
-from edsl.jobs.buckets.BucketCollection import BucketCollection
-from edsl.language_models.key_management.KeyLookup import KeyLookup
-from edsl.jobs.runners.JobsRunnerStatus import JobsRunnerStatus
-
-VisibilityType = Literal["private", "public", "unlisted"]
-from edsl.Base import Base
-
-
-@dataclass
-class RunEnvironment:
-    cache: Optional[Cache] = None
-    bucket_collection: Optional[BucketCollection] = None
-    key_lookup: Optional[KeyLookup] = None
-    jobs_runner_status: Optional["JobsRunnerStatus"] = None
-
-
-@dataclass
-class RunParameters(Base):
-    n: int = 1
-    progress_bar: bool = False
-    stop_on_exception: bool = False
-    check_api_keys: bool = False
-    verbose: bool = True
-    print_exceptions: bool = True
-    remote_cache_description: Optional[str] = None
-    remote_inference_description: Optional[str] = None
-    remote_inference_results_visibility: Optional[VisibilityType] = "unlisted"
-    skip_retry: bool = False
-    raise_validation_errors: bool = False
-    disable_remote_cache: bool = False
-    disable_remote_inference: bool = False
-    job_uuid: Optional[str] = None
-
-    def to_dict(self, add_edsl_version=False) -> dict:
-        d = asdict(self)
-        if add_edsl_version:
-            from edsl import __version__
-
-            d["edsl_version"] = __version__
-            d["edsl_class_name"] = "RunConfig"
-        return d
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "RunConfig":
-        return cls(**data)
-
-    def code(self):
-        return f"RunConfig(**{self.to_dict()})"
-
-    @classmethod
-    def example(cls) -> "RunConfig":
-        return cls()
-
-
-@dataclass
-class RunConfig:
-    environment: RunEnvironment
-    parameters: RunParameters
-
-    def add_environment(self, environment: RunEnvironment):
-        self.environment = environment
-
-    def add_bucket_collection(self, bucket_collection: BucketCollection):
-        self.environment.bucket_collection = bucket_collection
-
-    def add_cache(self, cache: Cache):
-        self.environment.cache = cache
-
-    def add_key_lookup(self, key_lookup: KeyLookup):
-        self.environment.key_lookup = key_lookup
-
-
-"""This module contains the Answers class, which is a helper class to hold the answers to a survey."""
-
-from collections import UserDict
-from edsl.data_transfer_models import EDSLResultObjectInput
-
-
-class Answers(UserDict):
-    """Helper class to hold the answers to a survey."""
-
-    def add_answer(
-        self, response: EDSLResultObjectInput, question: "QuestionBase"
-    ) -> None:
-        """Add a response to the answers dictionary."""
-        answer = response.answer
-        comment = response.comment
-        generated_tokens = response.generated_tokens
-        # record the answer
-        if generated_tokens:
-            self[question.question_name + "_generated_tokens"] = generated_tokens
-        self[question.question_name] = answer
-        if comment:
-            self[question.question_name + "_comment"] = comment
-
-    def replace_missing_answers_with_none(self, survey: "Survey") -> None:
-        """Replace missing answers with None. Answers can be missing if the agent skips a question."""
-        for question_name in survey.question_names:
-            if question_name not in self:
-                self[question_name] = None
-
-    def to_dict(self):
-        """Return a dictionary of the answers."""
-        return self.data
-
-    @classmethod
-    def from_dict(cls, d):
-        """Return an Answers object from a dictionary."""
-        return cls(d)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/jobs/results_exceptions_handler.py

@@ -1,98 +0,0 @@
-from typing import Optional, TYPE_CHECKING, Protocol
-import sys
-from edsl.scenarios.FileStore import HTMLFileStore
-from edsl.config import CONFIG
-from edsl.coop.coop import Coop
-
-
-class ResultsProtocol(Protocol):
-    """Protocol defining the required interface for Results objects."""
-
-    @property
-    def has_unfixed_exceptions(self) -> bool: ...
-
-    @property
-    def task_history(self) -> "TaskHistoryProtocol": ...
-
-
-class TaskHistoryProtocol(Protocol):
-    """Protocol defining the required interface for TaskHistory objects."""
-
-    @property
-    def indices(self) -> list: ...
-
-    def html(self, cta: str, open_in_browser: bool, return_link: bool) -> str: ...
-
-
-class RunParametersProtocol(Protocol):
-    """Protocol defining the required interface for RunParameters objects."""
-
-    @property
-    def print_exceptions(self) -> bool: ...
-
-
-class ResultsExceptionsHandler:
-    """Handles exception reporting and display functionality."""
-
-    def __init__(
-        self, results: ResultsProtocol, parameters: RunParametersProtocol
-    ) -> None:
-        self.results = results
-        self.parameters = parameters
-
-        self.open_in_browser = self._get_browser_setting()
-        self.remote_logging = self._get_remote_logging_setting()
-
-    def _get_browser_setting(self) -> bool:
-        """Determine if exceptions should be opened in browser based on config."""
-        setting = CONFIG.get("EDSL_OPEN_EXCEPTION_REPORT_URL")
-        if setting == "True":
-            return True
-        elif setting == "False":
-            return False
-        else:
-            raise Exception(
-                "EDSL_OPEN_EXCEPTION_REPORT_URL must be either True or False"
-            )
-
-    def _get_remote_logging_setting(self) -> bool:
-        """Get remote logging setting from coop."""
-        try:
-            coop = Coop()
-            return coop.edsl_settings["remote_logging"]
-        except Exception as e:
-            # print(e)
-            return False
-
-    def _generate_error_message(self, indices) -> str:
-        """Generate appropriate error message based on number of exceptions."""
-        msg = f"Exceptions were raised in {len(indices)} interviews.\n"
-        if len(indices) > 5:
-            msg += f"Exceptions were raised in the following interviews: {indices}.\n"
-        return msg
-
-    def handle_exceptions(self) -> None:
-        """Handle exceptions by printing messages and generating reports as needed."""
-        if not (
-            self.results.has_unfixed_exceptions and self.parameters.print_exceptions
-        ):
-            return
-
-        # Print error message
-        error_msg = self._generate_error_message(self.results.task_history.indices)
-        print(error_msg, file=sys.stderr)
-
-        # Generate HTML report
-        filepath = self.results.task_history.html(
-            cta="Open report to see details.",
-            open_in_browser=self.open_in_browser,
-            return_link=True,
-        )
-
-        # Handle remote logging if enabled
-        if self.remote_logging:
-            filestore = HTMLFileStore(filepath)
-            coop_details = filestore.push(description="Error report")
-            print(coop_details)
-
-        print("Also see: https://docs.expectedparrot.com/en/latest/exceptions.html")

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/questions/data_structures.py

@@ -1,20 +0,0 @@
-from typing import Any, Optional, TypedDict
-from pydantic import BaseModel
-
-
-class RawEdslAnswerDict(TypedDict):
-    answer: Any
-    comment: Optional[str]
-    generated_tokens: Optional[str]
-
-
-class BaseResponse(BaseModel):
-    answer: Any
-    comment: Optional[str] = None
-    generated_tokens: Optional[str] = None
-
-
-class EdslAnswerDict(TypedDict):
-    answer: Any
-    comment: Optional[str]
-    generated_tokens: Optional[str]