edsl 0.1.38.dev4__py3-none-any.whl → 0.1.39__py3-none-any.whl

edsl/Base.py

@@ -2,61 +2,22 @@
 
 from abc import ABC, abstractmethod, ABCMeta
 import gzip
-import io
 import json
 from typing import Any, Optional, Union
 from uuid import UUID
 
-# from edsl.utilities.MethodSuggesterMixin import MethodSuggesterMixin
-
-from edsl.utilities.utilities import is_notebook
-
-
-class RichPrintingMixin:
-    pass
-
-    # def print(self):
-    #     print(self)
-
-
-#     """Mixin for rich printing and persistence of objects."""
-
-#     def _for_console(self):
-#         """Return a string representation of the object for console printing."""
-#         from rich.console import Console
-
-#         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()
-#         return self.__repr__()
-
-#     def print(self):
-#         """Print the object to the console."""
-#         from edsl.utilities.utilities import is_notebook
-
-#         if is_notebook():
-#             from IPython.display import display
-
-#             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 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,
     ):
@@ -64,7 +25,41 @@ class PersistenceMixin:
         from edsl.coop import Coop
 
         c = Coop(url=expected_parrot_url)
-        return c.create(self, description, visibility)
+        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(
@@ -95,6 +90,7 @@ class PersistenceMixin:
         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,
     ):
@@ -107,7 +103,7 @@ class PersistenceMixin:
         from edsl.coop import Coop
 
         coop = Coop()
-        return coop.patch(uuid, url, description, value, visibility)
+        return coop.patch(uuid, url, description, alias, value, visibility)
 
     @classmethod
     def search(cls, query):
@@ -117,6 +113,13 @@ class PersistenceMixin:
         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.
 
@@ -126,15 +129,9 @@ class PersistenceMixin:
         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]
+            filename = filename[:-8]
         if filename.endswith("json"):
-            filename = filename[:-4]
-            # warnings.warn(
-            #    "Do not apply the file extensions. The filename should not end with 'json'."
-            # )
+            filename = filename[:-5]
 
         if compress:
             full_file_name = filename + ".json.gz"
@@ -196,9 +193,15 @@ class RegisterSubclassesMeta(ABCMeta):
             RegisterSubclassesMeta._registry[cls.__name__] = cls
 
     @staticmethod
-    def get_registry():
+    def get_registry(exclude_classes: Optional[list] = None):
         """Return the registry of subclasses."""
-        return dict(RegisterSubclassesMeta._registry)
+        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:
@@ -209,45 +212,147 @@ class DiffMethodsMixin:
         return BaseDiff(self, other)
 
 
-class Base(
-    # RichPrintingMixin,
-    PersistenceMixin,
-    DiffMethodsMixin,
-    ABC,
-    metaclass=RegisterSubclassesMeta,
-):
-    """Base class for all classes in the package."""
+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 print(self, **kwargs):
-        if "format" in kwargs:
-            if kwargs["format"] not in ["html", "markdown", "rich", "latex"]:
-                raise ValueError(f"Format '{kwargs['format']}' not supported.")
+    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
 
-        if hasattr(self, "table"):
-            return self.table()
+    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:
-            return self
+            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__()
 
-    def summary(self, format="table"):
-        from edsl import Scenario
-
-        d = self._summary()
-        if format == "table":
-            return Scenario(d).table()
-        if format == "dict":
-            return d
-        if format == "json":
-            return Scenario(d).json()
-        if format == "yaml":
-            return Scenario(d).yaml()
-        if format == "html":
-            return Scenario(d).table(tablefmt="html")
+
+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."""
@@ -264,42 +369,11 @@ class Base(
         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 html(self):
-    #     html_string = self._repr_html_()
-    #     import tempfile
-    #     import webbrowser
-
-    #     with tempfile.NamedTemporaryFile("w", delete=False, suffix=".html") as f:
-    #         # print("Writing HTML to", f.name)
-    #         f.write(html_string)
-    #         webbrowser.open(f.name)
-
-    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."""
@@ -308,6 +382,13 @@ class Base(
     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."""

edsl/__init__.py

@@ -5,7 +5,9 @@ BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 ROOT_DIR = os.path.dirname(BASE_DIR)
 
 from edsl.__version__ import __version__
-from edsl.config import Config, CONFIG
+
+# from edsl.config import Config, CONFIG
+
 from edsl.agents.Agent import Agent
 from edsl.agents.AgentList import AgentList
 
@@ -18,6 +20,7 @@ from edsl.questions import QuestionFreeText
 from edsl.questions import QuestionFunctional
 from edsl.questions import QuestionLikertFive
 from edsl.questions import QuestionList
+from edsl.questions import QuestionMatrix
 from edsl.questions import QuestionLinearScale
 from edsl.questions import QuestionNumerical
 from edsl.questions import QuestionYesNo
@@ -25,22 +28,27 @@ from edsl.questions import QuestionBudget
 from edsl.questions import QuestionRank
 from edsl.questions import QuestionTopK
 
-from edsl.scenarios import Scenario
-from edsl.scenarios import ScenarioList
+from edsl.scenarios.Scenario import Scenario
+from edsl.scenarios.ScenarioList import ScenarioList
 from edsl.scenarios.FileStore import FileStore
 
 # from edsl.utilities.interface import print_dict_with_rich
 from edsl.surveys.Survey import Survey
-from edsl.language_models.registry import Model
+from edsl.language_models.model import Model
 from edsl.language_models.ModelList import ModelList
+
 from edsl.results.Results import Results
 from edsl.data.Cache import Cache
-from edsl.data.CacheEntry import CacheEntry
+
+# from edsl.data.CacheEntry import CacheEntry
 from edsl.data.CacheHandler import set_session_cache, unset_session_cache
-from edsl.shared import shared_globals
+
+# from edsl.shared import shared_globals
+
 from edsl.jobs.Jobs import Jobs
 from edsl.notebooks.Notebook import Notebook
-from edsl.study.Study import Study
+
+# from edsl.study.Study import Study
 
 # from edsl.conjure.Conjure import Conjure
 from edsl.coop.coop import Coop

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.38.dev4"
+__version__ = "0.1.39"