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

edsl/results/ResultsExportMixin.py

@@ -1,45 +0,0 @@
-"""Mixin class for exporting results."""
-
-from functools import wraps
-from typing import Literal, Optional, Union
-
-from edsl.results.DatasetExportMixin import DatasetExportMixin
-
-
-def to_dataset(func):
-    """Convert the Results object to a Dataset object before calling the function."""
-
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        """Return the function with the Results object converted to a Dataset object."""
-        if self.__class__.__name__ == "Results":
-            return func(self.select(), *args, **kwargs)
-        elif self.__class__.__name__ == "AgentList":
-            return func(self.to_dataset(), *args, **kwargs)
-        else:
-            return func(self, *args, **kwargs)
-
-    wrapper._is_wrapped = True
-    return wrapper
-
-
-def decorate_methods_from_mixin(cls, mixin_cls):
-    for attr_name, attr_value in mixin_cls.__dict__.items():
-        if callable(attr_value) and not attr_name.startswith("__"):
-            setattr(cls, attr_name, to_dataset(attr_value))
-    return cls
-
-
-class ResultsExportMixin(DatasetExportMixin):
-    """Mixin class for exporting Results objects."""
-
-    def __init_subclass__(cls, **kwargs):
-        super().__init_subclass__(**kwargs)
-        decorate_methods_from_mixin(cls, DatasetExportMixin)
-
-
-if __name__ == "__main__":
-    # pass
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/results/TextEditor.py

@@ -1,50 +0,0 @@
-try:
-    import gradio as gr
-except ImportError:
-    print("Gradio is not installed. Please install it using `pip install gradio`")
-
-import time
-
-
-class TextEditor:
-    def __init__(self, initial_text=""):
-        self.text = initial_text
-        self._text_saved = False
-
-    def save_text(self, new_text):
-        self.text = new_text
-        self._text_saved = True
-        return "Text saved successfully!"
-
-    def edit_gui(self):
-        js_code = """
-        async (text) => {
-            await navigator.clipboard.writeText(text);
-            return "Copied to clipboard!";
-        }
-        """
-
-        with gr.Blocks() as interface:
-            text_area = gr.Textbox(
-                value=self.text, lines=10, label="Edit Text", placeholder="Type here..."
-            )
-
-            with gr.Row():
-                save_btn = gr.Button("Save")
-                copy_btn = gr.Button("Copy to Clipboard")
-
-            output = gr.Textbox(label="Status")
-
-            save_btn.click(fn=self.save_text, inputs=[text_area], outputs=[output])
-
-            # Add copy functionality
-            copy_btn.click(
-                fn=None, inputs=text_area, outputs=output, api_name=False, js=js_code
-            )
-
-        interface.launch(share=False, prevent_thread_lock=True)
-
-        while not self._text_saved:
-            time.sleep(0.1)
-
-        return self.text

edsl/results/results_fetch_mixin.py

@@ -1,33 +0,0 @@
-"""Mixin for fetching data from results."""
-
-from functools import partial
-from itertools import chain
-
-
-class ResultsFetchMixin:
-    """Mixin for fetching data from results."""
-
-    def _fetch_list(self, data_type: str, key: str) -> list:
-        """
-        Return a list of values from the data for a given data type and key.
-
-        Uses the filtered data, not the original data.
-
-        Example:
-
-        >>> from edsl.results import Results
-        >>> r = Results.example()
-        >>> r._fetch_list('answer', 'how_feeling')
-        ['OK', 'Great', 'Terrible', 'OK']
-        """
-        returned_list = []
-        for row in self.data:
-            returned_list.append(row.sub_dicts[data_type].get(key, None))
-
-        return returned_list
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/results/results_tools_mixin.py

@@ -1,98 +0,0 @@
-class ResultsToolsMixin:
-    def get_themes(
-        self,
-        field: str,
-        context: str,
-        max_values=100,
-        num_themes: int = 10,
-        seed=None,
-        progress_bar=False,
-        print_exceptions=False,
-    ) -> list:
-        values = [
-            str(txt)[:1000]
-            for txt in self.shuffle(seed=seed).select(field).to_list()[:max_values]
-        ]
-        from edsl import ScenarioList
-        from edsl.questions import QuestionList, QuestionCheckBox
-
-        q = QuestionList(
-            question_text=f"""
-        {context}
-        Here are some examples: { values }. 
-        What are some 5-8 word themes that would mostly capture these examples?
-        Please shoot for {num_themes} as target number of themes.
-        """,
-            question_name="themes",
-        )
-        results = q.run(print_exceptions=print_exceptions, progress_bar=progress_bar)
-        return results.select("themes").first()
-
-    def answers_to_themes(
-        self,
-        field,
-        context: str,
-        themes: list,
-        progress_bar=False,
-        print_exceptions=False,
-    ) -> dict:
-        from edsl import ScenarioList
-        from edsl import QuestionCheckBox
-
-        values = self.select(field).to_list()
-        scenarios = ScenarioList.from_list("field", values).add_value(
-            "context", context
-        )
-        q = QuestionCheckBox(
-            question_text="""
-            {{ context }}
-            Consider the following response: 
-
-            " {{ field }} "
-
-            Please check the themes that apply to these examples.
-            If blank, please check 'None'.
-            """,
-            question_options=themes + ["None", "Other"],
-            question_name="themes",
-        )
-        results = q.by(scenarios).run(
-            progress_bar=progress_bar, print_exceptions=print_exceptions
-        )
-        return {k: v for k, v in results.select("field", "themes").to_list()}
-
-    def apply_themes(self, field: str, new_field: str, answers_to_themes: dict):
-        def translate(x):
-            return answers_to_themes.get(x, "Other")
-
-        self.mutate(f"{new_field} = f({field})", functions_dict={"f": translate})
-        return self
-
-    def auto_theme(
-        self,
-        field: str,
-        context: str,
-        themes: list[str],
-        newfield: str = None,
-        progress_bar=False,
-        print_exceptions=False,
-    ) -> tuple:
-        """
-        :param field: The field to be themed.
-        :param context: The context of the field.
-        :param themes: The list of themes.
-        :param newfield: The new field name.
-
-        """
-
-        if not newfield:
-            newfield = f"{field}_themes"
-
-        answers_to_themes = self.answers_to_themes(
-            field=field,
-            context=context,
-            themes=themes,
-            progress_bar=progress_bar,
-            print_exceptions=print_exceptions,
-        )
-        return self.apply_themes(field, newfield, answers_to_themes), themes

edsl/scenarios/DocumentChunker.py

@@ -1,104 +0,0 @@
-from __future__ import annotations
-from typing import Optional, Generator, TYPE_CHECKING
-import copy
-
-if TYPE_CHECKING:
-    from edsl.scenarios.Scenario import Scenario
-    from edsl.scenarios.ScenarioList import ScenarioList
-
-
-class DocumentChunker:
-    def __init__(self, scenario: "Scenario"):
-        self.scenario = scenario
-
-    @staticmethod
-    def _line_chunks(text, num_lines: int) -> Generator[str, None, None]:
-        """Split a text into chunks of a given size.
-
-        :param text: The text to split.
-        :param num_lines: The number of lines in each chunk.
-
-        Example:
-
-        >>> list(DocumentChunker._line_chunks("This is a test.\\nThis is a test. This is a test.", 1))
-        ['This is a test.', 'This is a test. This is a test.']
-        """
-        lines = text.split("\n")
-        for i in range(0, len(lines), num_lines):
-            chunk = "\n".join(lines[i : i + num_lines])
-            yield chunk
-
-    @staticmethod
-    def _word_chunks(text, num_words: int) -> Generator[str, None, None]:
-        """Split a text into chunks of a given size.
-
-        :param text: The text to split.
-        :param num_words: The number of words in each chunk.
-
-        Example:
-
-        >>> list(DocumentChunker._word_chunks("This is a test.", 2))
-        ['This is', 'a test.']
-        """
-        words = text.split()
-        for i in range(0, len(words), num_words):
-            chunk = " ".join(words[i : i + num_words])
-            yield chunk
-
-    def chunk(
-        self,
-        field,
-        num_words: Optional[int] = None,
-        num_lines: Optional[int] = None,
-        include_original=False,
-        hash_original=False,
-    ) -> ScenarioList:
-        """Split a field into chunks of a given size.
-
-        :param field: The field to split.
-        :param num_words: The number of words in each chunk.
-        :param num_lines: The number of lines in each chunk.
-        :param include_original: Whether to include the original field in the new scenarios.
-        :param hash_original: Whether to hash the original field in the new scenarios.
-
-        If you specify `include_original=True`, the original field will be included in the new scenarios with an "_original" suffix.
-        """
-        from edsl.scenarios.ScenarioList import ScenarioList
-        import hashlib
-
-        if num_words is not None:
-            chunks = list(self._word_chunks(self.scenario[field], num_words))
-
-        if num_lines is not None:
-            chunks = list(self._line_chunks(self.scenario[field], num_lines))
-
-        if num_words is None and num_lines is None:
-            raise ValueError("You must specify either num_words or num_lines.")
-
-        if num_words is not None and num_lines is not None:
-            raise ValueError(
-                "You must specify either num_words or num_lines, but not both."
-            )
-
-        scenarios = []
-        for i, chunk in enumerate(chunks):
-            new_scenario = copy.deepcopy(self.scenario)
-            new_scenario[field] = chunk
-            new_scenario[field + "_chunk"] = i
-            new_scenario[field + "_char_count"] = len(chunk)
-            new_scenario[field + "_word_count"] = len(chunk.split())
-            if include_original:
-                if hash_original:
-                    new_scenario[field + "_original"] = hashlib.md5(
-                        self.scenario[field].encode()
-                    ).hexdigest()
-                else:
-                    new_scenario[field + "_original"] = self.scenario[field]
-            scenarios.append(new_scenario)
-        return ScenarioList(scenarios)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()