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

edsl/study/Study.py

@@ -1,520 +0,0 @@
-import copy
-import inspect
-import json
-import os
-import platform
-import socket
-from datetime import datetime
-from typing import Dict, Optional, Union
-from uuid import UUID, uuid4
-
-from ..caching import Cache
-#from edsl import set_session_cache, unset_session_cache
-from ..utilities.utilities import dict_hash
-from ..study.ObjectEntry import ObjectEntry
-from ..study.ProofOfWork import ProofOfWork
-from ..study.SnapShot import SnapShot
-
-
-class Study:
-    """A study organizes a series of EDSL objects.
-
-    ```python
-    with Study(name = "cool_study") as study:
-        q = QuestionFreeText.example()
-        results = q.run()
-    ```
-
-    The `study` object is a context manager.
-    It lets you group a series of events and objects together.
-
-    >>> with Study(name = "cool_study", verbose = False) as study:
-    ...     from edsl import QuestionFreeText
-    ...     q = QuestionFreeText.example()
-    >>> len(study.objects)
-    1
-    >>> _ = os.system("rm cool_study.json")
-
-
-    It records all the edsl objects that are created during the study.
-    On exit, is saves them to a study file.
-
-    """
-
-    def __init__(
-        self,
-        name: Optional[str] = None,
-        filename: Optional[str] = None,
-        description: Optional[str] = None,
-        objects: Optional[Dict[str, ObjectEntry]] = None,
-        cache: Optional[Cache] = None,
-        coop: bool = False,
-        use_study_cache=True,
-        overwrite_on_change=True,
-        proof_of_work=None,
-        proof_of_work_difficulty: int = None,
-        namespace: Optional[dict] = None,
-        verbose: Optional[bool] = True,
-    ):
-        """
-        :param name: The name of the study.
-        :param description: A description of the study.
-        :param objects: A dictionary of objects to add to the study.
-        :param cache: A cache object to (potentially) use for the study.
-        :param filename: The path to the study file.
-        :param coop: Whether to push the study to coop.
-        :param use_study_cache: Whether to use the study cache.
-        :param overwrite_on_change: Whether to overwrite the study file if it has changed.
-
-        >>> s = Study()
-        Traceback (most recent call last):
-        ...
-        ValueError: You must provide a name or a filename for the study.
-
-        """
-        self.verbose = verbose
-
-        if name is None and filename is None:
-            raise ValueError("You must provide a name or a filename for the study.")
-
-        if filename is None:
-            self.filename = name
-        else:
-            self.filename = filename
-
-        if (
-            self.filename
-            and os.path.exists(self.filename + ".json")
-            and os.path.getsize(self.filename + ".json") > 0
-        ):
-            if self.verbose:
-                print(f"Using existing study file {self.filename}.json")
-            self._load_from_file()
-        else:
-            self.name = name
-            self.description = description
-            self.objects = objects or {}
-            self.cache = cache or Cache()
-            self.proof_of_work = proof_of_work or ProofOfWork()
-
-        # These always overwrite the saved study
-        self.coop = coop
-        self.use_study_cache = use_study_cache
-        self.overwrite_on_change = overwrite_on_change
-        self.proof_of_work_difficulty = proof_of_work_difficulty
-
-        self.starting_objects = copy.deepcopy(self.objects)
-
-        if namespace:
-            self._namespace = namespace
-        else:
-            self._namespace = None
-
-        self._create_mapping_dicts()
-
-    @property
-    def namespace(self):
-        return self._find_stack()
-
-    def _find_stack(self) -> dict:
-        "Finds the frame with the Study context"
-        # if self.verbose:
-        #    self.explore_stacks()
-        frame = inspect.currentframe()
-        candidate_frames = []
-        while frame:
-            if "Study" in frame.f_globals:
-                candidate_frames.append(frame)
-
-            frame = frame.f_back
-
-        found_variables_dict = {}
-        for frame in candidate_frames:
-            found_variables_dict.update(frame.f_globals)
-            found_variables_dict.update(frame.f_locals)
-
-        return found_variables_dict
-
-    def explore_stacks(self):
-        frame = inspect.currentframe()
-        count = 0
-        d = {}
-        while frame:
-            d[count] = "Study" in frame.f_globals.keys()
-            count += 1
-            from rich import print as rprint
-
-            print("Globals:")
-            rprint(frame.f_globals["__name__"])
-            rprint(frame.f_globals.keys())
-            print("Locals:")
-            rprint(frame.f_locals.keys())
-            print("\n")
-            frame = frame.f_back
-        return d
-
-    def _create_mapping_dicts(self):
-        self._name_to_object = {}
-        self._hash_to_name = {}
-        self._name_to_oe = {}
-        name_counts = {}
-        for hash, obj in self.objects.items():
-            new_name = obj.variable_name
-            if obj.variable_name in name_counts:
-                name_counts[obj.variable_name] += 1
-                new_name = obj.variable_name + "_" + str(name_counts[obj.variable_name])
-            else:
-                name_counts[obj.variable_name] = 1
-            self._name_to_object[new_name] = obj.object
-            self._hash_to_name[hash] = new_name
-
-    def __len__(self):
-        return len(self.objects)
-
-    def __eq__(self, other):
-        return self.objects.keys() == other.objects.keys()
-
-    @property
-    def name_to_object(self):
-        """
-        >>> s = Study.example()
-        >>> s.name_to_object
-        {'q': Question('free_text', question_name = \"""how_are_you\""", question_text = \"""How are you?\""")}
-        """
-        self._create_mapping_dicts()
-        return self._name_to_object
-
-    @property
-    def hash_to_name(self):
-        self._create_mapping_dicts()
-        return self._hash_to_name
-
-    def __getattr__(self, name):
-        return self.name_to_object[name]
-
-    @classmethod
-    def from_file(cls, filename: str):
-        """Load a study from a file."""
-        if filename.endswith(".json"):
-            filename = filename[:-5]
-        return cls(filename=filename)
-
-    def _load_from_file(self):
-        """Load the study from a file.
-
-        >>> import tempfile
-        >>> filename = tempfile.NamedTemporaryFile(delete=False)
-        >>> study = Study(name = "poo", filename = filename.name)
-        >>> study.save()
-        Saving study to ...
-        >>> study2 = Study(filename = filename.name)
-        Using existing study file ...
-        >>> study2.name
-        'poo'
-        """
-        with open(self.filename + ".json", "r") as f:
-            d = json.load(f)
-            d["cache"] = Cache.from_dict(d["cache"])
-            d["proof_of_work"] = ProofOfWork.from_dict(d["proof_of_work"])
-            d["objects"] = {
-                hash: ObjectEntry.from_dict(obj_dict)
-                for hash, obj_dict in d["objects"].items()
-            }
-            self.__dict__.update(d)
-
-    def __enter__(self):
-        """
-        >>> #s = Study(name = "temp", use_study_cache = True, verbose = False)
-        >>> #_ = s.__enter__()
-        >>> #from edsl.config import CONFIG
-        >>> #hasattr(CONFIG, "EDSL_SESSION_CACHE")
-        >>> #_ = s.__exit__(None, None, None)
-        >>> #len(s.objects)
-        >>> #os.remove("temp.json")
-
-        """
-        if self.verbose:
-            print("Existing objects in study:")
-            self.print()
-        snapshot = SnapShot(self.namespace, exclude=[self])
-        if self.use_study_cache:
-            if self.verbose:
-                print("Using study cache.")
-            #set_session_cache(self.cache)
-
-        if snapshot.edsl_objects:
-            raise ValueError(
-                "You have EDSL objects in the global namespace.",
-                "Please remove them before starting a study or put under the 'Study' context manager."
-                "Objects found:",
-                snapshot.edsl_objects,
-            )
-        return self
-
-    def __hash__(self) -> int:
-        return dict_hash(list(self.objects.keys()))
-
-    def study_diff(self):
-        ## Need to also report missing.
-        from ..base import BaseDiff
-
-        raise NotImplementedError("Need to implement this.")
-
-    def print(self):
-        from rich.console import Console
-        from rich.table import Table
-
-        console = Console()
-        table = Table(title="Study")
-        table.add_column("Original Name")
-        table.add_column("Study Name")
-        table.add_column("Class")
-        table.add_column("Description")
-        table.add_column("Hash")
-        table.add_column("Coop info")
-        table.add_column("Created")
-
-        for obj_hash, obj in self.objects.items():
-            url = (
-                ""
-                if not hasattr(obj, "coop_info") or obj.coop_info is None
-                else obj.coop_info.get("url", "")
-            )
-            table.add_row(
-                obj.variable_name,
-                self.hash_to_name[obj_hash],
-                obj.edsl_class_name,
-                obj.description,
-                obj.hash,
-                url,
-                datetime.fromtimestamp(obj.created_at).strftime("%Y-%m-%d %H:%M:%S"),
-            )
-        # Add cache at the end
-        table.add_row(
-            "N/A - Study Cache",
-            "cache",
-            "Cache",
-            f"Cache of study, entries: {len(self.cache)}",
-            str(hash(self.cache)),
-            "N/A",
-            "N/A",
-        )
-        console.print(table)
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        snapshot = SnapShot(namespace=self.namespace, exclude=[self])
-        # print("Frame objects are:", snapshot.namespace.keys())
-        # breakpoint()
-        if self.use_study_cache:
-            #unset_session_cache()
-            pass
-
-        for variable_name, object in snapshot.edsl_objects.items():
-            self._add_edsl_object(object=object, variable_name=variable_name)
-
-        if not self.starting_objects:
-            if self.verbose:
-                print(f"New study saved to {self.filename}.json")
-            self.save()
-
-        if self.starting_objects and list(self.starting_objects.keys()) == list(
-            self.objects.keys()
-        ):
-            if self.verbose:
-                print("Study perfectly replicated.")
-        else:
-            if self.verbose:
-                print("Starting hashes:", self.starting_objects.keys())
-                print("Current hashes:", self.objects.keys())
-            if self.starting_objects:
-                missing = set(self.starting_objects.keys()) - set(self.objects.keys())
-                added = set(self.objects.keys()) - set(self.starting_objects.keys())
-                # breakpoint()
-                print("Study did not perfectly replicate.")
-                for hash in missing:
-                    print(f"Missing object: {self.starting_objects[hash]}")
-                for hash in added:
-                    print(f"Added object: {self.objects[hash]}")
-                if self.overwrite_on_change:
-                    print("Overwriting study file.")
-                    self.save()
-                else:
-                    print(
-                        "Please save the study file with a new name or call study iwth 'overwrite_on_change=True' to overwrite the existing study file."
-                    )
-
-        if self.coop:
-            self.push()
-            if self.overwrite_on_change:
-                self.save()
-            else:
-                raise ValueError(
-                    "If you want to push to coop, you must save the study file with a new name or call study iwth 'overwrite_on_change=True' to overwrite the existing study file."
-                )
-
-        if self.verbose:
-            print("Objects in study now:")
-            self.print()
-
-        if self.proof_of_work_difficulty:
-            print("Adding proof of work to study...")
-            from edsl.study.ProofOfWork import ProofOfWork
-
-            # TODO: Need to check if hashes are the same.
-            if not self.proof_of_work.input_data:
-                self.proof_of_work.add_input_data(str(self.__hash__()))
-            self.proof_of_work.add_proof(self.proof_of_work_difficulty)
-            print(
-                "Proof of work added to study with difficulty ",
-                self.proof_of_work_difficulty,
-            )
-            print(self.proof_of_work)
-            self.save()
-
-    def to_dict(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "objects": {hash: obj.to_dict() for hash, obj in self.objects.items()},
-            "filename": self.filename,
-            "cache": self.cache.to_dict(),
-            "use_study_cache": self.use_study_cache,
-            "overwrite_on_change": self.overwrite_on_change,
-            "proof_of_work": self.proof_of_work.to_dict(),
-        }
-
-    def versions(self):
-        """Return a dictionary of objects grouped by variable name."""
-        d = {}
-        for _, obj_entry in self.objects.items():
-            if obj_entry.variable_name not in d:
-                d[obj_entry.variable_name] = [obj_entry]
-            else:
-                d[obj_entry.variable_name].append(obj_entry)
-
-        return d
-
-    def diff(self, variable_name: str, index1: int, index2: int):
-        """Return the difference between the versions of an object."""
-        versions = self.versions()[variable_name]
-        diff = versions[index2].object - versions[index1].object
-        return diff
-
-    @classmethod
-    def example(cls, verbose=False, randomize=False):
-        import tempfile
-
-        study_file = tempfile.NamedTemporaryFile()
-        with cls(filename=study_file.name, verbose=verbose) as study:
-            from ..questions import QuestionFreeText
-
-            q = QuestionFreeText.example(randomize=randomize)
-        return study
-
-    @classmethod
-    def from_dict(cls, d):
-        d["cache"] = Cache.from_dict(d["cache"])
-        d["objects"] = {
-            str(object_hash): ObjectEntry.from_dict(obj_dict)
-            for object_hash, obj_dict in d["objects"].items()
-        }
-        d["proof_of_work"] = ProofOfWork.from_dict(d["proof_of_work"])
-        return cls(**d)
-
-    def save(self):
-        if self.verbose:
-            print(f"Saving study to {self.filename}.json")
-        with open(self.filename + ".json", "w") as f:
-            json.dump(self.to_dict(), f, indent=4)
-
-    def _get_system_info(self):
-        return {
-            "platform": platform.platform(),
-            "system": platform.system(),
-            "processor": platform.processor(),
-            "hostname": socket.gethostname(),
-        }
-
-    @staticmethod
-    def _get_description(object):
-        text = ""
-        if hasattr(object, "__len__"):
-            text += f"Num. entries: {len(object)}"
-        if hasattr(object, "question_name"):
-            text += f"Question name: {object.question_name}"
-        return text
-
-    def _add_edsl_object(self, object, variable_name, description=None) -> None:
-        """
-        >>> s = Study.example()
-        >>> from edsl import QuestionLinearScale
-        >>> s._add_edsl_object(QuestionLinearScale.example(), 'q')
-        >>> len(s)
-        2
-        """
-        if description is None:
-            description = self._get_description(object)
-        oe = ObjectEntry(
-            variable_name=variable_name, object=object, description=description
-        )
-        if oe.hash in self.objects:
-            return
-        else:
-            self.objects[oe.hash] = oe
-
-    def push(self) -> dict:
-        """Push the objects to coop."""
-
-        from edsl.coop.coop import Coop
-
-        coop = Coop()
-        return coop.create(self, description=self.description)
-
-    def delete_object(self, identifier: Union[str, UUID]):
-        """
-        Delete an EDSL object from the study.
-
-        :param identifier: Either the variable name or the hash of the object to delete
-        :raises ValueError: If the object is not found in the study
-        """
-        if isinstance(identifier, str):
-            # If identifier is a variable name or a string representation of UUID
-            for hash, obj_entry in list(self.objects.items()):
-                if obj_entry.variable_name == identifier or hash == identifier:
-                    del self.objects[hash]
-                    self._create_mapping_dicts()  # Update internal mappings
-                    if self.verbose:
-                        print(f"Deleted object with identifier: {identifier}")
-                    return
-            raise ValueError(f"No object found with identifier: {identifier}")
-        elif isinstance(identifier, UUID):
-            # If identifier is a UUID object
-            hash_str = str(identifier)
-            if hash_str in self.objects:
-                del self.objects[hash_str]
-                self._create_mapping_dicts()  # Update internal mappings
-                if self.verbose:
-                    print(f"Deleted object with hash: {hash_str}")
-                return
-            raise ValueError(f"No object found with hash: {hash_str}")
-        else:
-            raise TypeError(
-                "Identifier must be either a string (variable name or hash) or a UUID object"
-            )
-
-    @classmethod
-    def pull(cls, url_or_uuid: Union[str, UUID]):
-        """Pull the object from coop."""
-        from edsl.coop import Coop
-
-        coop = Coop()
-        return coop.get(url_or_uuid, "study")
-
-    def __repr__(self):
-        return f"""Study(name = "{self.name}", description = "{self.description}", objects = {self.objects}, cache = {self.cache}, filename = "{self.filename}", coop = {self.coop}, use_study_cache = {self.use_study_cache}, overwrite_on_change = {self.overwrite_on_change})"""
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/study/__init__.py

@@ -1,6 +0,0 @@
-from .ObjectEntry import ObjectEntry
-from .ProofOfWork import ProofOfWork
-from .SnapShot import SnapShot
-from .Study import Study
-
-__all__ = ["ObjectEntry", "ProofOfWork", "SnapShot", "Study"]

edsl/utilities/interface.py

@@ -1,135 +0,0 @@
-"""A module for displaying data in various formats.
-
-This module provides utility functions for formatting and displaying data,
-primarily used by the Results module for printing results.
-"""
-
-# Only print_results_long is actively used in the codebase (in results.py)
-# The rest of the functions are kept for reference but are not imported in __init__.py
-
-
-def print_results_long(results, max_rows=None):
-    """
-    Format results data as a rich console table with columns for index, key, and value.
-    
-    Args:
-        results: The Results object to display
-        max_rows: Optional maximum number of rows to display
-    """
-    from rich.console import Console
-    from rich.table import Table
-
-    console = Console(record=True)
-    table = Table(show_header=True, header_style="bold magenta")
-    table.add_column("Result index", style="dim")
-    table.add_column("Key", style="dim")
-    table.add_column("Value", style="dim")
-    list_of_dicts = results.to_dicts()
-    num_rows = 0
-    for i, results_dict in enumerate(list_of_dicts):
-        for key, value in results_dict.items():
-            table.add_row(str(i), key, str(value))
-            num_rows += 1
-        if max_rows is not None and num_rows >= max_rows:
-            break
-    console.print(table)
-
-
-# The rest of these functions are not actively used by the codebase
-# They are kept but commented out for potential future reference
-
-"""
-def create_image(console, image_filename):
-    font_size = 15
-    from PIL import Image, ImageDraw, ImageFont
-
-    text = console.export_text()
-
-    font_size = 15
-    font = ImageFont.load_default()
-    text_width, text_height = get_multiline_textsize(text, font)
-    image = Image.new(
-        "RGB", (text_width + 20, text_height + 20), color=(255, 255, 255)
-    )
-    d = ImageDraw.Draw(image)
-    d.multiline_text((10, 10), text, font=font, fill=(0, 0, 0))
-    image.save(image_filename)
-
-
-def display_table(console, table, filename):
-    if filename is not None:
-        with open(filename, "w") as f:
-            with console.capture() as capture:
-                console.print(table)
-            f.write(capture.get())
-        create_image(console, filename + ".png")
-    else:
-        console.print(table)
-
-
-def gen_html_sandwich(html_inner, interactive=False):
-    return html_inner
-
-
-def view_html(html):
-    import tempfile
-    import webbrowser
-
-    with tempfile.NamedTemporaryFile("w", delete=False, suffix=".html") as f:
-        url = "file://" + f.name
-        f.write(html)
-    webbrowser.open(url)
-
-
-def get_multiline_textsize(text, font):
-    lines = text.split("\n")
-    max_width = 0
-    total_height = 0
-
-    for line in lines:
-        box = font.getbbox(line)
-        width, height = box[2], box[3]
-        max_width = max(max_width, width)
-        total_height += height
-
-    return max_width, total_height
-
-
-def print_dict_with_rich(d, key_name="Key", value_name="Value", filename=None):
-    from rich.console import Console
-    from rich.table import Table
-
-    console = Console(record=True)
-    table = Table(show_header=True, header_style="bold magenta")
-    table.add_column(key_name, style="dim")
-    table.add_column(value_name, style="dim")
-    for key, value in d.items():
-        table.add_row(key, str(value))
-    console.print(table)
-
-
-def print_table_with_rich(data, filename=None):
-    from rich.console import Console
-    from rich.table import Table
-
-    console = Console(record=True)
-    table = Table(show_header=True, header_style="bold magenta", row_styles=["", "dim"])
-
-    if not data:
-        console.print("No data provided!")
-        return
-
-    for key in data[0].keys():
-        table.add_column(key, style="dim")
-
-    for row in data:
-        table.add_row(*[str(value) for value in row.values()])
-
-    console.print(table)
-"""
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()