edsl 0.1.39__py3-none-any.whl → 0.1.39.dev1__py3-none-any.whl

edsl/Base.py

@@ -2,22 +2,61 @@
 
 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,
     ):
@@ -25,41 +64,7 @@ class PersistenceMixin:
         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()
+        return c.create(self, description, visibility)
 
     @classmethod
     def pull(
@@ -90,7 +95,6 @@ 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,
     ):
@@ -103,7 +107,7 @@ class PersistenceMixin:
         from edsl.coop import Coop
 
         coop = Coop()
-        return coop.patch(uuid, url, description, alias, value, visibility)
+        return coop.patch(uuid, url, description, value, visibility)
 
     @classmethod
     def search(cls, query):
@@ -113,13 +117,6 @@ 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.
 
@@ -129,9 +126,15 @@ class PersistenceMixin:
         if filename.endswith("json.gz"):
             import warnings
 
-            filename = filename[:-8]
+            # 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[:-5]
+            filename = filename[:-4]
+            # warnings.warn(
+            #    "Do not apply the file extensions. The filename should not end with 'json'."
+            # )
 
         if compress:
             full_file_name = filename + ".json.gz"
@@ -193,15 +196,9 @@ class RegisterSubclassesMeta(ABCMeta):
             RegisterSubclassesMeta._registry[cls.__name__] = cls
 
     @staticmethod
-    def get_registry(exclude_classes: Optional[list] = None):
+    def get_registry():
         """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
-        }
+        return dict(RegisterSubclassesMeta._registry)
 
 
 class DiffMethodsMixin:
@@ -212,147 +209,45 @@ class DiffMethodsMixin:
         return BaseDiff(self, other)
 
 
-def is_iterable(obj):
-    try:
-        iter(obj)
-    except TypeError:
-        return False
-    return True
-
+class Base(
+    # RichPrintingMixin,
+    PersistenceMixin,
+    DiffMethodsMixin,
+    ABC,
+    metaclass=RegisterSubclassesMeta,
+):
+    """Base class for all classes in the package."""
 
-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 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 _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_()
-            )
+        if hasattr(self, "table"):
+            return self.table()
         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_()
-            )
+            return self
 
     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 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")
 
     def keys(self):
         """Return the keys of the object."""
@@ -369,11 +264,42 @@ 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."""
@@ -382,13 +308,6 @@ 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,9 +5,7 @@ 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
 
@@ -20,7 +18,6 @@ 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
@@ -28,27 +25,22 @@ from edsl.questions import QuestionBudget
 from edsl.questions import QuestionRank
 from edsl.questions import QuestionTopK
 
-from edsl.scenarios.Scenario import Scenario
-from edsl.scenarios.ScenarioList import ScenarioList
+from edsl.scenarios import Scenario
+from edsl.scenarios 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.model import Model
+from edsl.language_models.registry 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.39"
+__version__ = "0.1.39.dev1"