edsl 0.1.46__py3-none-any.whl → 0.1.47__py3-none-any.whl

edsl/auto/utilities.py

@@ -1,218 +0,0 @@
-from textwrap import dedent
-import random
-from typing import List, TypeVar, Generator, Optional
-from edsl.auto.StageBase import StageBase
-from edsl.utilities.naming_utilities import sanitize_string
-from edsl import Agent, Survey, Model, Cache, AgentList
-from edsl import QuestionFreeText, Scenario
-from edsl import QuestionMultipleChoice, Scenario, Agent, ScenarioList
-
-StageClassType = TypeVar("StageClassType", bound=StageBase)
-
-
-def gen_pipeline(stages_list: List[StageClassType]) -> StageBase:
-    """Takes as input a list of Stage classes & returns a pipeline of instantiated stages.
-    A pipeline is a linked list of stages where each stage has a next_stage attribute.
-
-    """
-    pipeline = stages_list[0]()
-    last_stage = pipeline
-    for stage in stages_list[1:]:
-        while last_stage.next_stage is not None:  # find the end of the pipeline
-            last_stage = last_stage.next_stage
-        stage_to_add = stage()
-        last_stage.next_stage = stage_to_add
-    return pipeline
-
-
-q_eligibility = QuestionMultipleChoice(
-    question_text=dedent(
-        """\
-        Consider this set of question: '{{ questions }}'.
-        Consider this persona: '{{ persona }}'.
-        Would this persona be able to answer all of these questions?
-        """
-    ),
-    question_options=["No", "Yes"],
-    question_name="eligibility",
-)
-
-
-def agent_list_eligibility(
-    agent_list: AgentList,
-    survey: Optional[Survey] = None,
-    model: Optional[Model] = None,
-    cache: Optional[Cache] = None,
-) -> List[bool]:
-    """
-    Returns whether each agent in a list is elgible for a survey i.e., can answer every question.
-
-    >>> from edsl.language_models import LanguageModel
-    >>> m = LanguageModel.example(canned_response = "1", test_model = True)
-    >>> agent_list_eligibility(AgentList.example())
-    [True, True]
-    >>> agent_list_eligibility(AgentList.example().add_trait('persona', 2*["Cool dude"]), survey = Survey.example(), model = m)
-    [True, True]
-    """
-    if survey is None:
-        return [True] * len(agent_list)
-    if "persona" not in agent_list.all_traits:
-        raise ValueError(
-            f"Each agent needs to have a persona attribute; traits are {agent_list.all_traits}"
-        )
-    sl = agent_list.select("persona").to_scenario_list()
-    sl.add_value("questions", [q.question_text for q in survey._questions])
-    results = q_eligibility.by(sl).by(model).run(cache=cache)
-    return [r == "Yes" for r in results.select("eligibility").to_list()]
-
-
-def agent_eligibility(
-    agent: Agent,
-    survey: Survey,
-    model: Optional[Model] = None,
-    cache: Optional[Cache] = None,
-) -> bool:
-    """NB: This could be parallelized.
-
-    >>> from edsl.language_models import LanguageModel
-    >>> m = LanguageModel.example(canned_response = "1", test_model = True)
-    >>> agent_eligibility(agent = Agent.example().add_trait({'persona': "Persona"}), survey = Survey.example(), model = m)
-    True
-
-    """
-    model = model or Model()
-
-    questions = [q.question_text for q in survey._questions]
-    persona = agent.traits["persona"]
-    return (
-        q_eligibility(model=model, questions=questions, persona=persona, cache=cache)
-        == "Yes"
-    )
-
-
-def gen_agent_traits(dimension_dict: dict, seed_value: Optional[str] = None):
-    """
-    >>> dimension_dict = {'attitude':['positive', 'negative']}
-    >>> ag = gen_agent_traits(dimension_dict)
-    >>> a = next(ag)
-    >>> a == {'attitude': 'positive'} or a == {'attitude': 'negative'}
-    True
-    >>> len([next(ag) for _ in range(100)])
-    100
-    """
-    if seed_value is None:
-        seed_value = "edsl"
-
-    random.seed(seed_value)
-
-    while True:
-        new_agent_traits = {}
-        for key, list_of_values in dimension_dict.items():
-            new_agent_traits[key] = random.choice(list_of_values)
-        yield new_agent_traits
-
-
-def agent_generator(
-    persona: str,
-    dimension_dict: dict,
-    model: Optional[Model] = None,
-    cache: Optional["Cache"] = None,
-) -> Generator["Results", None, None]:
-    """
-    >>> from edsl.language_models import LanguageModel
-    >>> m = LanguageModel.example(canned_response = "This is a cool dude.", test_model = True)
-    >>> ag = agent_generator(persona = "Base person", dimension_dict = {'attitude':['Positive', 'Negative']}, model = m)
-    >>> next(ag).select('new_agent_persona').first()
-    'This is a cool dude.'
-    >>> next(ag).select('new_agent_persona').first()
-    'This is a cool dude.'
-    """
-
-    if model is None:
-        model = Model()
-
-    q = QuestionFreeText(
-        question_text=dedent(
-            """\
-    Consider this persona: '{{ persona }}'.
-    Now imagine writing a new persona with these traits: 
-    '{{ new_agent_traits }}'
-    Please write this persona as a narrative.
-    """
-        ),
-        question_name="new_agent_persona",
-    )
-    agent_trait_generator = gen_agent_traits(dimension_dict)
-    codebook = {sanitize_string(k): k for k in dimension_dict.keys()}
-    while True:
-        new_agent_traits = next(agent_trait_generator)
-        yield q(
-            persona=persona,
-            new_agent_traits=new_agent_traits,
-            codebook=codebook,
-            just_answer=False,
-            cache=cache,
-            model=model,
-        )
-
-
-def create_agents(
-    agent_generator: Generator["Results", None, None],
-    survey: Optional[Survey] = None,
-    num_agents=11,
-) -> AgentList:
-    """
-    >>> from edsl.language_models import LanguageModel
-    >>> m = LanguageModel.example(canned_response = "This is a cool dude.", test_model = True)
-    >>> ag = agent_generator(persona = "Base person", dimension_dict = {'attitude':['Positive', 'Negative']}, model = m)
-    >>> new_agent_list = create_agents(agent_generator = ag)
-    >>> new_agent_list
-
-    """
-    agent_list = AgentList([])
-
-    MAX_ITERATIONS_MULTIPLIER = 2
-    iterations = 0
-
-    while len(agent_list) < num_agents:
-        iterations += 1
-        candidate_agent = next(agent_generator)
-        codebook = candidate_agent.select("codebook").to_list()[0]
-
-        koobedoc = {v: k for k, v in codebook.items()}
-        persona = candidate_agent.select("new_agent_persona").to_list()[0]
-        traits = candidate_agent.select("new_agent_traits").to_list()[0]
-        new_traits = {koobedoc[key]: value for key, value in traits.items()} | {
-            "persona": persona
-        }
-        agent = Agent(traits=new_traits, codebook=codebook)
-        if survey is not None:
-            if agent_eligibility(agent, survey):
-                agent_list.append(agent)
-            else:
-                print("Agent not eligible")
-        else:
-            agent_list.append(agent)
-
-        if iterations > MAX_ITERATIONS_MULTIPLIER * num_agents:
-            raise Exception("Too many failures")
-
-    return agent_list
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
-    # from edsl.language_models import LanguageModel
-
-    # m = LanguageModel.example(canned_response="This is a cool dude.", test_model=True)
-    # ag = agent_generator(
-    #     persona="Base person",
-    #     dimension_dict={"attitude": ["Positive", "Negative"]},
-    #     model=m,
-    # )
-    # example = [next(ag).select("new_agent_persona").first() for _ in range(10)]
-    # dimension_dict = {"attitude": ["positive", "negative"]}
-    # ag = gen_agent_traits(dimension_dict)
-    # example = [next(ag) for _ in range(100)]

edsl/base/Base.py

@@ -1,279 +0,0 @@
-"""Base class for all classes in the package. It provides rich printing and persistence of objects."""
-
-from abc import ABC, abstractmethod, ABCMeta
-import gzip
-import io
-import json
-from typing import Any, Optional, Union
-from uuid import UUID
-from IPython.display import display
-from rich.console import Console
-
-
-class RichPrintingMixin:
-    """Mixin for rich printing and persistence of objects."""
-
-    def _for_console(self):
-        """Return a string representation of the object for console printing."""
-        with io.StringIO() as buf:
-            console = Console(file=buf, record=True)
-            table = self.rich_print()
-            console.print(table)
-            return console.export_text()
-
-    def __str__(self):
-        """Return a string representation of the object for console printing."""
-        return self._for_console()
-
-    def print(self):
-        """Print the object to the console."""
-        from edsl.utilities.utilities import is_notebook
-
-        if is_notebook():
-            display(self.rich_print())
-        else:
-            from rich.console import Console
-
-            console = Console()
-            console.print(self.rich_print())
-
-
-class PersistenceMixin:
-    """Mixin for saving and loading objects to and from files."""
-
-    def push(
-        self,
-        description: Optional[str] = None,
-        visibility: Optional[str] = "unlisted",
-    ):
-        """Post the object to coop."""
-        from edsl.coop import Coop
-
-        c = Coop()
-        return c.create(self, description, visibility)
-
-    @classmethod
-    def pull(cls, id_or_url: Union[str, UUID], exec_profile=None):
-        """Pull the object from coop."""
-        from edsl.coop import Coop
-
-        if id_or_url.startswith("http"):
-            uuid_value = id_or_url.split("/")[-1]
-        else:
-            uuid_value = id_or_url
-
-        c = Coop()
-
-        return c._get_base(cls, uuid_value, exec_profile=exec_profile)
-
-    @classmethod
-    def delete(cls, id_or_url: Union[str, UUID]):
-        """Delete the object from coop."""
-        from edsl.coop import Coop
-
-        c = Coop()
-        return c._delete_base(cls, id_or_url)
-
-    @classmethod
-    def patch(
-        cls,
-        id_or_url: Union[str, UUID],
-        description: Optional[str] = None,
-        value: Optional[Any] = None,
-        visibility: Optional[str] = None,
-    ):
-        """
-        Patch an uploaded objects attributes.
-        - `description` changes the description of the object on Coop
-        - `value` changes the value of the object on Coop. **has to be an EDSL object**
-        - `visibility` changes the visibility of the object on Coop
-        """
-        from edsl.coop import Coop
-
-        c = Coop()
-        return c._patch_base(cls, id_or_url, description, value, visibility)
-
-    @classmethod
-    def search(cls, query):
-        """Search for objects on coop."""
-        from edsl.coop import Coop
-
-        c = Coop()
-        return c.search(cls, query)
-
-    def save(self, filename, compress=True):
-        """Save the object to a file as zippped JSON.
-
-        >>> obj.save("obj.json.gz")
-
-        """
-        if filename.endswith("json.gz"):
-            import warnings
-
-            warnings.warn(
-                "Do not apply the file extensions. The filename should not end with 'json.gz'."
-            )
-            filename = filename[:-7]
-        if filename.endswith("json"):
-            filename = filename[:-4]
-            warnings.warn(
-                "Do not apply the file extensions. The filename should not end with 'json'."
-            )
-
-        if compress:
-            with gzip.open(filename + ".json.gz", "wb") as f:
-                f.write(json.dumps(self.to_dict()).encode("utf-8"))
-        else:
-            with open(filename + ".json", "w") as f:
-                f.write(json.dumps(self.to_dict()))
-
-    @staticmethod
-    def open_compressed_file(filename):
-        with gzip.open(filename, "rb") as f:
-            file_contents = f.read()
-            file_contents_decoded = file_contents.decode("utf-8")
-            d = json.loads(file_contents_decoded)
-        return d
-
-    @staticmethod
-    def open_regular_file(filename):
-        with open(filename, "r") as f:
-            d = json.loads(f.read())
-        return d
-
-    @classmethod
-    def load(cls, filename):
-        """Load the object from a file.
-
-        >>> obj = cls.load("obj.json.gz")
-
-        """
-
-        if filename.endswith("json.gz"):
-            d = cls.open_compressed_file(filename)
-        elif filename.endswith("json"):
-            d = cls.open_regular_file(filename)
-        else:
-            try:
-                d = cls.open_compressed_file(filename)
-            except:
-                d = cls.open_regular_file(filename)
-            finally:
-                raise ValueError("File must be a json or json.gz file")
-
-        return cls.from_dict(d)
-
-
-class RegisterSubclassesMeta(ABCMeta):
-    """Metaclass for registering subclasses."""
-
-    _registry = {}
-
-    def __init__(cls, name, bases, nmspc):
-        """Register the class in the registry upon creation."""
-        super(RegisterSubclassesMeta, cls).__init__(name, bases, nmspc)
-        if cls.__name__ != "Base":
-            RegisterSubclassesMeta._registry[cls.__name__] = cls
-
-    @staticmethod
-    def get_registry():
-        """Return the registry of subclasses."""
-        return dict(RegisterSubclassesMeta._registry)
-
-
-class DiffMethodsMixin:
-    def __sub__(self, other):
-        """Return the difference between two objects."""
-        from edsl.BaseDiff import BaseDiff
-
-        return BaseDiff(self, other)
-
-
-class Base(
-    RichPrintingMixin,
-    PersistenceMixin,
-    DiffMethodsMixin,
-    ABC,
-    metaclass=RegisterSubclassesMeta,
-):
-    """Base class for all classes in the package."""
-
-    # def __getitem__(self, key):
-    #     return getattr(self, key)
-
-    # @abstractmethod
-    # def _repr_html_(self) -> str:
-    #     raise NotImplementedError("This method is not implemented yet.")
-
-    # @abstractmethod
-    # def _repr_(self) -> str:
-    #     raise NotImplementedError("This method is not implemented yet.")
-
-    def keys(self):
-        """Return the keys of the object."""
-        _keys = list(self.to_dict().keys())
-        if "edsl_version" in _keys:
-            _keys.remove("edsl_version")
-        if "edsl_class_name" in _keys:
-            _keys.remove("edsl_class_name")
-        return _keys
-
-    def values(self):
-        """Return the values of the object."""
-        data = self.to_dict()
-        keys = self.keys()
-        return {data[key] for key in keys}
-
-    def _repr_html_(self):
-        from edsl.utilities.utilities import data_to_html
-
-        return data_to_html(self.to_dict())
-
-    def __eq__(self, other):
-        """Return whether two objects are equal."""
-        import inspect
-
-        if not isinstance(other, self.__class__):
-            return False
-        if "sort" in inspect.signature(self.to_dict).parameters:
-            return self.to_dict(sort=True) == other.to_dict(sort=True)
-        else:
-            return self.to_dict() == other.to_dict()
-
-    @abstractmethod
-    def example():
-        """This method should be implemented by subclasses."""
-        raise NotImplementedError("This method is not implemented yet.")
-
-    @abstractmethod
-    def rich_print():
-        """This method should be implemented by subclasses."""
-        raise NotImplementedError("This method is not implemented yet.")
-
-    @abstractmethod
-    def to_dict():
-        """This method should be implemented by subclasses."""
-        raise NotImplementedError("This method is not implemented yet.")
-
-    @abstractmethod
-    def from_dict():
-        """This method should be implemented by subclasses."""
-        raise NotImplementedError("This method is not implemented yet.")
-
-    @abstractmethod
-    def code():
-        """This method should be implemented by subclasses."""
-        raise NotImplementedError("This method is not implemented yet.")
-
-    def show_methods(self, show_docstrings=True):
-        """Show the methods of the object."""
-        public_methods_with_docstrings = [
-            (method, getattr(self, method).__doc__)
-            for method in dir(self)
-            if callable(getattr(self, method)) and not method.startswith("_")
-        ]
-        if show_docstrings:
-            for method, documentation in public_methods_with_docstrings:
-                print(f"{method}: {documentation}")
-        else:
-            return [x[0] for x in public_methods_with_docstrings]