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

edsl/Base.py

@@ -1,426 +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 json
-from typing import Any, Optional, Union
-from uuid import UUID
-
-
-class PersistenceMixin:
-    """Mixin for saving and loading objects to and from files."""
-
-    def duplicate(self, add_edsl_version=False):
-        """Return a duplicate of the object."""
-        return self.from_dict(self.to_dict(add_edsl_version=False))
-
-    def push(
-        self,
-        description: Optional[str] = None,
-        alias: Optional[str] = None,
-        visibility: Optional[str] = "unlisted",
-        expected_parrot_url: Optional[str] = None,
-    ):
-        """Post the object to coop."""
-        from edsl.coop import Coop
-
-        c = Coop(url=expected_parrot_url)
-        return c.create(self, description, alias, visibility)
-
-    def to_yaml(self, add_edsl_version=False, filename: str = None) -> Union[str, None]:
-        import yaml
-
-        output = yaml.dump(self.to_dict(add_edsl_version=add_edsl_version))
-        if not filename:
-            return output
-
-        with open(filename, "w") as f:
-            f.write(output)
-
-    @classmethod
-    def from_yaml(cls, yaml_str: Optional[str] = None, filename: Optional[str] = None):
-        if yaml_str is None and filename is not None:
-            with open(filename, "r") as f:
-                yaml_str = f.read()
-                return cls.from_yaml(yaml_str=yaml_str)
-        elif yaml_str and filename is None:
-            import yaml
-
-            d = yaml.load(yaml_str, Loader=yaml.FullLoader)
-            return cls.from_dict(d)
-        else:
-            raise ValueError("Either yaml_str or filename must be provided.")
-
-    def create_download_link(self):
-        from tempfile import NamedTemporaryFile
-        from edsl.scenarios.FileStore import FileStore
-
-        with NamedTemporaryFile(suffix=".json.gz") as f:
-            self.save(f.name)
-            print(f.name)
-            fs = FileStore(path=f.name)
-        return fs.create_link()
-
-    @classmethod
-    def pull(
-        cls,
-        url_or_uuid: Optional[Union[str, UUID]] = None,
-        # expected_parrot_url: Optional[str] = None,
-    ):
-        """Pull the object from coop.
-
-        Args:
-            url_or_uuid: Either a UUID string or a URL pointing to the object
-            expected_parrot_url: Optional URL for the Parrot server
-        """
-        from edsl.coop import Coop
-        from edsl.coop.utils import ObjectRegistry
-
-        object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
-        coop = Coop()
-
-        # Determine if input is URL or UUID
-        if "www" in url_or_uuid:
-            url_or_uuid = url_or_uuid.replace("www", "api")
-        if url_or_uuid and (
-            "http://" in str(url_or_uuid) or "https://" in str(url_or_uuid)
-        ):
-            return coop.get(url=url_or_uuid, expected_object_type=object_type)
-        else:
-            return coop.get(uuid=url_or_uuid, expected_object_type=object_type)
-
-    @classmethod
-    def delete(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
-        """Delete the object from coop."""
-        from edsl.coop import Coop
-
-        coop = Coop()
-        return coop.delete(uuid, url)
-
-    @classmethod
-    def patch(
-        cls,
-        uuid: Optional[Union[str, UUID]] = None,
-        url: Optional[str] = None,
-        description: Optional[str] = None,
-        alias: 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
-
-        coop = Coop()
-        return coop.patch(uuid, url, description, alias, 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 store(self, d: dict, key_name: Optional[str] = None):
-        if key_name is None:
-            index = len(d)
-        else:
-            index = key_name
-        d[index] = self
-
-    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
-
-            filename = filename[:-8]
-        if filename.endswith("json"):
-            filename = filename[:-5]
-
-        if compress:
-            full_file_name = filename + ".json.gz"
-            with gzip.open(full_file_name, "wb") as f:
-                f.write(json.dumps(self.to_dict()).encode("utf-8"))
-        else:
-            full_file_name = filename + ".json"
-            with open(filename + ".json", "w") as f:
-                f.write(json.dumps(self.to_dict()))
-
-        print("Saved to", full_file_name)
-
-    @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 + ".json.gz")
-            except:
-                d = cls.open_regular_file(filename + ".json")
-            # 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(exclude_classes: Optional[list] = None):
-        """Return the registry of subclasses."""
-        if exclude_classes is None:
-            exclude_classes = []
-        return {
-            k: v
-            for k, v in dict(RegisterSubclassesMeta._registry).items()
-            if k not in exclude_classes
-        }
-
-
-class DiffMethodsMixin:
-    def __sub__(self, other):
-        """Return the difference between two objects."""
-        from edsl.BaseDiff import BaseDiff
-
-        return BaseDiff(self, other)
-
-
-def is_iterable(obj):
-    try:
-        iter(obj)
-    except TypeError:
-        return False
-    return True
-
-
-class RepresentationMixin:
-    def json(self):
-        return json.loads(json.dumps(self.to_dict(add_edsl_version=False)))
-
-    def to_dataset(self):
-        from edsl.results.Dataset import Dataset
-
-        return Dataset.from_edsl_object(self)
-
-    def view(self):
-        "Displays an interactive / perspective view of the object"
-        return self.to_dataset().view()
-
-    # def print(self, format="rich"):
-    #     return self.to_dataset().table()
-
-    def display_dict(self):
-        display_dict = {}
-        d = self.to_dict(add_edsl_version=False)
-        for key, value in d.items():
-            if isinstance(value, dict):
-                for k, v in value.items():
-                    display_dict[f"{key}:{k}"] = v
-            elif isinstance(value, list):
-                for i, v in enumerate(value):
-                    display_dict[f"{key}:{i}"] = v
-            else:
-                display_dict[key] = value
-        return display_dict
-
-    def print(self, format="rich"):
-        from rich.table import Table
-        from rich.console import Console
-
-        table = Table(title=self.__class__.__name__)
-        table.add_column("Key", style="bold")
-        table.add_column("Value", style="bold")
-
-        for key, value in self.display_dict().items():
-            table.add_row(key, str(value))
-
-        console = Console(record=True)
-        console.print(table)
-
-    def help(obj):
-        """
-        Extract all public instance methods and their docstrings from a class instance.
-
-        Args:
-            obj: The instance to inspect
-
-        Returns:
-            dict: A dictionary where keys are method names and values are their docstrings
-        """
-        import inspect
-
-        if inspect.isclass(obj):
-            raise TypeError("Please provide a class instance, not a class")
-
-        methods = {}
-
-        # Get all members of the instance
-        for name, member in inspect.getmembers(obj):
-            # Skip private and special methods (those starting with underscore)
-            if name.startswith("_"):
-                continue
-
-            # Check if it's specifically an instance method
-            if inspect.ismethod(member):
-                # Get the docstring (or empty string if none exists)
-                docstring = inspect.getdoc(member) or ""
-                methods[name] = docstring
-
-        from edsl.results.Dataset import Dataset
-
-        d = Dataset(
-            [
-                {"method": list(methods.keys())},
-                {"documentation": list(methods.values())},
-            ]
-        )
-        return d
-
-    def _repr_html_(self):
-        from edsl.results.TableDisplay import TableDisplay
-
-        if hasattr(self, "_summary"):
-            summary_dict = self._summary()
-            summary_line = "".join([f" {k}: {v};" for k, v in summary_dict.items()])
-            class_name = self.__class__.__name__
-            docs = getattr(self, "__documentation__", "")
-            return (
-                "<p>"
-                + f"<a href='{docs}'>{class_name}</a>"
-                + summary_line
-                + "</p>"
-                + self.table()._repr_html_()
-            )
-        else:
-            class_name = self.__class__.__name__
-            documenation = getattr(self, "__documentation__", "")
-            summary_line = "<p>" + f"<a href='{documenation}'>{class_name}</a>" + "</p>"
-            display_dict = self.display_dict()
-            return (
-                summary_line
-                + TableDisplay.from_dictionary_wide(display_dict)._repr_html_()
-            )
-
-    def __str__(self):
-        return self.__repr__()
-
-
-class HashingMixin:
-    def __hash__(self) -> int:
-        """Return a hash of the question."""
-        from edsl.utilities.utilities import dict_hash
-
-        return dict_hash(self.to_dict(add_edsl_version=False))
-
-    def __eq__(self, other):
-        """Return whether two objects are equal."""
-        return hash(self) == hash(other)
-
-
-class Base(
-    RepresentationMixin,
-    PersistenceMixin,
-    DiffMethodsMixin,
-    HashingMixin,
-    ABC,
-    metaclass=RegisterSubclassesMeta,
-):
-    """Base class for all classes in the package."""
-
-    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}
-
-    @abstractmethod
-    def example():
-        """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.")
-
-    def to_json(self):
-        return json.dumps(self.to_dict())
-
-    def store(self, d: dict, key_name: Optional[str] = None):
-        if key_name is None:
-            index = len(d)
-        else:
-            index = key_name
-        d[index] = self
-
-    @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]

edsl/BaseDiff.py

@@ -1,260 +0,0 @@
-import difflib
-import json
-from typing import Any, Dict, Tuple
-from collections import UserList
-import inspect
-
-
-class BaseDiffCollection(UserList):
-    def __init__(self, diffs=None):
-        if diffs is None:
-            diffs = []
-        super().__init__(diffs)
-
-    def apply(self, obj: Any):
-        for diff in self:
-            obj = diff.apply(obj)
-        return obj
-
-    def add_diff(self, diff) -> "BaseDiffCollection":
-        self.append(diff)
-        return self
-
-
-class DummyObject:
-    def __init__(self, object_dict):
-        self.object_dict = object_dict
-
-    def to_dict(self):
-        return self.object_dict
-
-
-class BaseDiff:
-    def __init__(
-        self, obj1: Any, obj2: Any, added=None, removed=None, modified=None, level=0
-    ):
-        self.level = level
-
-        self.obj1 = obj1
-        self.obj2 = obj2
-
-        if "sort" in inspect.signature(obj1.to_dict).parameters:
-            self._dict1 = obj1.to_dict(sort=True)
-            self._dict2 = obj2.to_dict(sort=True)
-        else:
-            self._dict1 = obj1.to_dict()
-            self._dict2 = obj2.to_dict()
-        self._obj_class = type(obj1)
-
-        self.added = added
-        self.removed = removed
-        self.modified = modified
-
-    def __bool__(self):
-        return bool(self.added or self.removed or self.modified)
-
-    @property
-    def added(self):
-        if self._added is None:
-            self._added = self._find_added()
-        return self._added
-
-    def __add__(self, other):
-        return self.apply(other)
-
-    @added.setter
-    def added(self, value):
-        self._added = value if value is not None else self._find_added()
-
-    @property
-    def removed(self):
-        if self._removed is None:
-            self._removed = self._find_removed()
-        return self._removed
-
-    @removed.setter
-    def removed(self, value):
-        self._removed = value if value is not None else self._find_removed()
-
-    @property
-    def modified(self):
-        if self._modified is None:
-            self._modified = self._find_modified()
-        return self._modified
-
-    @modified.setter
-    def modified(self, value):
-        self._modified = value if value is not None else self._find_modified()
-
-    def _find_added(self) -> Dict[Any, Any]:
-        return {k: self._dict2[k] for k in self._dict2 if k not in self._dict1}
-
-    def _find_removed(self) -> Dict[Any, Any]:
-        return {k: self._dict1[k] for k in self._dict1 if k not in self._dict2}
-
-    def _find_modified(self) -> Dict[Any, Tuple[Any, Any, str]]:
-        modified = {}
-        for k in self._dict1:
-            if k in self._dict2 and self._dict1[k] != self._dict2[k]:
-                if isinstance(self._dict1[k], str) and isinstance(self._dict2[k], str):
-                    diff = self._diff_strings(self._dict1[k], self._dict2[k])
-                    modified[k] = (self._dict1[k], self._dict2[k], diff)
-                elif isinstance(self._dict1[k], dict) and isinstance(
-                    self._dict2[k], dict
-                ):
-                    diff = self._diff_dicts(self._dict1[k], self._dict2[k])
-                    modified[k] = (self._dict1[k], self._dict2[k], diff)
-                elif isinstance(self._dict1[k], list) and isinstance(
-                    self._dict2[k], list
-                ):
-                    d1 = dict(zip(range(len(self._dict1[k])), self._dict1[k]))
-                    d2 = dict(zip(range(len(self._dict2[k])), self._dict2[k]))
-                    diff = BaseDiff(
-                        DummyObject(d1), DummyObject(d2), level=self.level + 1
-                    )
-                    modified[k] = (self._dict1[k], self._dict2[k], diff)
-                else:
-                    modified[k] = (self._dict1[k], self._dict2[k], "")
-        return modified
-
-    @staticmethod
-    def is_json(string_that_could_be_json: str) -> bool:
-        try:
-            json.loads(string_that_could_be_json)
-            return True
-        except json.JSONDecodeError:
-            return False
-
-    def _diff_dicts(self, dict1: Dict[str, Any], dict2: Dict[str, Any]) -> str:
-        diff = BaseDiff(DummyObject(dict1), DummyObject(dict2), level=self.level + 1)
-        return diff
-
-    def _diff_strings(self, str1: str, str2: str) -> str:
-        if self.is_json(str1) and self.is_json(str2):
-            diff = self._diff_dicts(json.loads(str1), json.loads(str2))
-            return diff
-        diff = difflib.ndiff(str1.splitlines(), str2.splitlines())
-        return diff
-
-    def apply(self, obj: Any):
-        """Apply the diff to the object."""
-
-        new_obj_dict = obj.to_dict()
-        for k, v in self.added.items():
-            new_obj_dict[k] = v
-        for k in self.removed.keys():
-            del new_obj_dict[k]
-        for k, (v1, v2, diff) in self.modified.items():
-            new_obj_dict[k] = v2
-
-        return obj.from_dict(new_obj_dict)
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "added": self.added,
-            "removed": self.removed,
-            "modified": self.modified,
-            "obj1": self._dict1,
-            "obj2": self._dict2,
-            "obj_class": self._obj_class.__name__,
-            "level": self.level,
-        }
-
-    @classmethod
-    def from_dict(cls, diff_dict: Dict[str, Any], obj1: Any, obj2: Any):
-        return cls(
-            obj1=obj1,
-            obj2=obj2,
-            added=diff_dict["added"],
-            removed=diff_dict["removed"],
-            modified=diff_dict["modified"],
-            level=diff_dict["level"],
-        )
-
-    class Results(UserList):
-        def __init__(self, prepend=" ", level=0):
-            super().__init__()
-            self.prepend = prepend
-            self.level = level
-
-        def append(self, item):
-            super().append(self.prepend * self.level + item)
-
-    def __str__(self):
-        prepend = " "
-        result = self.Results(level=self.level, prepend="\t")
-        if self.added:
-            result.append("Added keys and values:")
-            for k, v in self.added.items():
-                result.append(prepend + f"  {k}: {v}")
-        if self.removed:
-            result.append("Removed keys and values:")
-            for k, v in self.removed.items():
-                result.append(f"  {k}: {v}")
-        if self.modified:
-            result.append("Modified keys and values:")
-            for k, (v1, v2, diff) in self.modified.items():
-                result.append(f"Key: {k}:")
-                result.append(f"    Old value: {v1}")
-                result.append(f"    New value: {v2}")
-                if diff:
-                    result.append(f"    Diff:")
-                    try:
-                        for line in diff:
-                            result.append(f"      {line}")
-                    except:
-                        result.append(f"      {diff}")
-        return "\n".join(result)
-
-    def __repr__(self):
-        return (
-            f"BaseDiff(obj1={self.obj1!r}, obj2={self.obj2!r}, added={self.added!r}, "
-            f"removed={self.removed!r}, modified={self.modified!r})"
-        )
-
-    def add_diff(self, diff) -> "BaseDiffCollection":
-        return BaseDiffCollection([self, diff])
-
-
-if __name__ == "__main__":
-    from edsl import Question
-
-    q_ft = Question.example("free_text")
-    q_mc = Question.example("multiple_choice")
-
-    diff1 = q_ft - q_mc
-    assert q_ft == q_mc + diff1
-    assert q_ft == diff1.apply(q_mc)
-    # new_q_mc = diff1.apply(q_ft)
-    # assert new_q_mc == q_mc
-
-    # new_q_mc = q_ft + diff1
-    # assert new_q_mc == q_mc
-
-    # new_q_mc = diff1 + q_ft
-    # assert new_q_mc == q_mc
-
-    # ## Test chain of diffs
-    q0 = Question.example("free_text")
-    q1 = q0.copy()
-    q1.question_text = "Why is Buzzard's Bay so named?"
-    diff1 = q1 - q0
-    q2 = q1.copy()
-    q2.question_name = "buzzard_bay"
-    diff2 = q2 - q1
-
-    diff_chain = diff1.add_diff(diff2)
-
-    new_q2 = diff_chain.apply(q0)
-    assert new_q2 == q2
-
-    new_q2 = diff_chain + q0
-    assert new_q2 == q2
-
-    # new_diffs = diff1.add_diff(diff1).add_diff(diff1)
-    # assert len(new_diffs) == 3
-
-    # q0 = Question.example("free_text")
-    # q1 = Question.example("free_text")
-    # q1.question_text = "Why is Buzzard's Bay so named?"
-    # q2 = q1.copy()