edsl 0.1.49__py3-none-any.whl → 0.1.51__py3-none-any.whl

edsl/dataset/smart_objects.py

@@ -1,96 +0,0 @@
-from typing import Optional
-
-
-class SmartInt(int):
-    pass
-
-
-class SmartFloat(float):
-    pass
-
-
-class SmartStr(str):
-    def clipboard(self) -> None:
-        try:
-            import pyperclip
-        except ImportError:
-            print(
-                "pyperclip is not installed. Run `pip install pyperclip` to install it."
-            )
-            return None
-
-        pyperclip.copy(self)
-        print("Text copied to clipboard.")
-
-    def write(self, filename: str):
-        with open(filename, "w") as f:
-            f.write(str(self))
-        return None
-
-    def _repr_html_(self):
-        pass
-
-    def markdown(self):
-        return SmartMarkdown(self)
-
-    def pdf(self, filename: Optional[str] = None):  # Markdown will have this as well
-        # renders the markdown as a pdf that can be downloaded
-        from ..utilities.markdown_to_pdf import MarkdownToPDF
-
-        return MarkdownToPDF(self, filename).preview()
-
-    def docx(self, filename: Optional[str] = None):
-        # renders the markdown as a docx that can be downloaded
-        from ..utilities.markdown_to_docx import MarkdownToDocx
-
-        return MarkdownToDocx(self, filename).preview()
-
-    def edit(self):
-        from edsl.results.TextEditor import TextEditor
-
-        editor = TextEditor(self)
-        self = self.__class__(editor.edit_gui())
-        # print(f"Updated text: {self}")
-
-
-class SmartMarkdown(SmartStr):
-    def _repr_markdown_(self):
-        return self
-
-    def _repr_html_(self):
-        from IPython.display import Markdown, display
-
-        display(Markdown(self))
-
-
-class SmartLaTeX(SmartStr):
-    def _repr_html_(self):
-        print(self)
-
-    def pdf(self, filename: Optional[str] = None):
-        from edsl.results.LaTeXToPDF import LaTeXToPDF
-
-        return LaTeXToPDF(self, filename).preview()
-
-    def docx(self, filename: Optional[str] = None):
-        from edsl.results.LaTeXToDocx import LaTeXToDocx
-
-        return LaTeXToDocx(self, filename).preview()
-
-    def edit(self):
-        from edsl.results.TextEditor import TextEditor
-
-        editor = TextEditor(self)
-        self = self.__class__(editor.edit_gui())
-        # print(f"Updated LaTeX: {self}")
-
-
-class FirstObject:
-    def __new__(self, value):
-        if isinstance(value, int):
-            return SmartInt(value)
-        if isinstance(value, float):
-            return SmartFloat(value)
-        if isinstance(value, str):
-            return SmartStr(value)
-        return value

edsl/exceptions/BaseException.py

@@ -1,21 +0,0 @@
-class BaseException(Exception):
-    relevant_doc = "https://docs.expectedparrot.com/"
-
-    def __init__(self, message, *, show_docs=True):
-        # Format main error message
-        formatted_message = [message.strip()]
-
-        # Add documentation links if requested
-        if show_docs:
-            if hasattr(self, "relevant_doc"):
-                formatted_message.append(
-                    f"\nFor more information, see:\n{self.relevant_doc}"
-                )
-            if hasattr(self, "relevant_notebook"):
-                formatted_message.append(
-                    f"\nFor a usage example, see:\n{self.relevant_notebook}"
-                )
-
-        # Join with double newlines for clear separation
-        final_message = "\n\n".join(formatted_message)
-        super().__init__(final_message)

edsl/exceptions/__init__.py

@@ -1,54 +0,0 @@
-# from .agents import (
-#     #    AgentAttributeLookupCallbackError,
-#     AgentCombinationError,
-#     #    AgentLacksLLMError,
-#     #    AgentRespondedWithBadJSONError,
-# )
-# from .configuration import (
-#     InvalidEnvironmentVariableError,
-#     MissingEnvironmentVariableError,
-# )
-# from .data import (
-#     DatabaseConnectionError,
-#     DatabaseCRUDError,
-#     DatabaseIntegrityError,
-# )
-
-# from .scenarios import (
-#     ScenarioError,
-# )
-
-# from .general import MissingAPIKeyError
-
-# from .jobs import JobsRunError, InterviewErrorPriorTaskCanceled, InterviewTimeoutError
-
-# from .language_models import (
-#     LanguageModelResponseNotJSONError,
-#     LanguageModelMissingAttributeError,
-#     LanguageModelAttributeTypeError,
-#     LanguageModelDoNotAddError,
-# )
-# from .questions import (
-#     QuestionAnswerValidationError,
-#     QuestionAttributeMissing,
-#     QuestionCreationValidationError,
-#     QuestionResponseValidationError,
-#     QuestionSerializationError,
-#     QuestionScenarioRenderError,
-# )
-# from .results import (
-#     ResultsBadMutationstringError,
-#     ResultsColumnNotFoundError,
-#     ResultsInvalidNameError,
-#     ResultsMutateError,
-# )
-# from .surveys import (
-#     SurveyCreationError,
-#     SurveyHasNoRulesError,
-#     SurveyRuleCannotEvaluateError,
-#     SurveyRuleCollectionHasNoRulesAtNodeError,
-#     SurveyRuleReferenceInRuleToUnknownQuestionError,
-#     SurveyRuleRefersToFutureStateError,
-#     SurveyRuleSendsYouBackwardsError,
-#     SurveyRuleSkipLogicSyntaxError,
-# )

edsl/exceptions/configuration.py

@@ -1,16 +0,0 @@
-class ConfigurationError(Exception):
-    """Base exception for errors."""
-
-    pass
-
-
-class InvalidEnvironmentVariableError(ConfigurationError):
-    """Raised when an environment variable is invalid."""
-
-    pass
-
-
-class MissingEnvironmentVariableError(ConfigurationError):
-    """Raised when an expected environment variable is missing."""
-
-    pass

edsl/exceptions/general.py

@@ -1,34 +0,0 @@
-import re
-from textwrap import dedent
-
-
-class GeneralErrors(Exception):
-    def __init__(self, message):
-        super().__init__(message)
-        self.message = message
-
-    def __str__(self):
-        return self.make_urls_clickable(self.message)
-
-    @staticmethod
-    def make_urls_clickable(text):
-        url_pattern = r"https?://[^\s]+"
-        urls = re.findall(url_pattern, text)
-        for url in urls:
-            clickable_url = f"\033]8;;{url}\007{url}\033]8;;\007"
-            text = text.replace(url, clickable_url)
-        return text
-
-
-class MissingAPIKeyError(GeneralErrors):
-    def __init__(self, full_message=None, model_name=None, inference_service=None):
-        if model_name and inference_service:
-            full_message = dedent(
-                f"""
-            An API Key for model `{model_name}` is missing from the .env file.
-            This key is associated with the inference service `{inference_service}`.
-            Please see https://docs.expectedparrot.com/en/latest/api_keys.html for more information.
-            """
-            )
-
-        super().__init__(full_message)

edsl/study/ObjectEntry.py

@@ -1,173 +0,0 @@
-import time
-import webbrowser
-from typing import Any, Dict, Optional, Type
-from edsl.questions import QuestionBase
-from edsl.base import RegisterSubclassesMeta
-
-
-class ObjectEntry:
-    def __init__(
-        self,
-        variable_name: str,
-        object: Any,
-        description: str,
-        coop_info: Optional[Dict[str, Any]] = None,
-        created_at: Optional[float] = None,
-        edsl_class_name: Optional[str] = None,
-    ):
-        """
-        Initialize an ObjectEntry instance.
-
-        :param variable_name: The name of the variable.
-        :param object: The object being wrapped.
-        :param description: A description of the object.
-        :param coop_info: Optional Coop information dictionary.
-        :param created_at: Optional creation timestamp. Defaults to current time.
-        :param edsl_class_name: Optional EDSL class name. Defaults to object's class name.
-        """
-        self.created_at = created_at or time.time()
-        self.variable_name = variable_name
-        self.object = object
-        self.edsl_class_name = edsl_class_name or object.__class__.__name__
-        self.description = description
-        self.coop_info = coop_info
-
-    @classmethod
-    def _get_class(cls, object_dict: Dict[str, Any]) -> Type:
-        """
-        Get the class of an object from its dictionary representation.
-
-        :param object_dict: The dictionary representation of the object.
-        :return: The class of the object.
-        """
-        class_name = object_dict["edsl_class_name"]
-        if class_name == "QuestionBase":
-            return QuestionBase
-        else:
-            return RegisterSubclassesMeta._registry[class_name]
-
-    def __repr__(self) -> str:
-        """
-        Return a string representation of the ObjectEntry instance.
-
-        :return: A string representation of the ObjectEntry instance.
-        """
-        return f"ObjectEntry(variable_name='{self.variable_name}', object={self.object!r}, description='{self.description}', coop_info={self.coop_info}, created_at={self.created_at}, edsl_class_name='{self.edsl_class_name}')"
-
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert the ObjectEntry instance to a dictionary.
-
-        :return: A dictionary representation of the ObjectEntry instance.
-        """
-        return {
-            "created_at": self.created_at,
-            "variable_name": self.variable_name,
-            "object": self.object.to_dict(),
-            "edsl_class_name": self.edsl_class_name,
-            "description": self.description,
-            "coop_info": self.coop_info,
-        }
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> "ObjectEntry":
-        """
-        Create an ObjectEntry instance from a dictionary.
-
-        :param d: The dictionary representation of the ObjectEntry instance.
-        :return: An ObjectEntry instance.
-        """
-        d["object"] = cls._get_class(d["object"]).from_dict(d["object"])
-        return cls(**d)
-
-    @property
-    def hash(self) -> str:
-        """
-        Compute the hash of the object.
-
-        :return: The hash of the object as a string.
-        """
-        return str(hash(self.object))
-
-    def add_to_namespace(self) -> None:
-        """
-        Add the object to the global namespace using its variable name.
-        """
-        globals()[self.variable_name] = self.object
-
-    @property
-    def coop_info(self) -> Optional[Dict[str, Any]]:
-        """
-        Get the Coop information for the object.
-
-        :return: The Coop information dictionary, if available.
-        """
-        return self._coop_info
-
-    @coop_info.setter
-    def coop_info(self, coop_info: Optional[Dict[str, Any]]) -> None:
-        """
-        Set the Coop information for the object.
-
-        :param coop_info: The Coop information dictionary.
-        """
-        self._coop_info = coop_info
-
-    def view_on_coop(self) -> None:
-        """
-        Open the object's Coop URL in a web browser.
-        """
-        if self.coop_info is None:
-            print("Object not pushed to coop")
-            return
-        url = self.coop_info.get("url")
-        webbrowser.open(url)
-
-    def push(self, refresh: Optional[bool] = False) -> Dict[str, Any]:
-        """
-        Push the object to the Coop.
-
-        :param refresh: Whether to refresh the Coop entry for the object.
-        :return: The Coop info dictionary.
-        """
-        if self.coop_info is None or refresh:
-            self.coop_info = self.object.push(description=self.description)
-            print(
-                f"Object {self.variable_name} pushed to coop with info: {self._coop_info}"
-            )
-        else:
-            print(
-                f"Object {self.variable_name} already pushed to coop with info: {self._coop_info}"
-            )
-
-    def __eq__(self, other: "ObjectEntry") -> bool:
-        """
-        Check if two ObjectEntry instances are equal.
-
-        :param other: The other ObjectEntry instance.
-        :return: True if the two instances are equal, False otherwise.
-        """
-        # if the other item is not "ObjectEntry" type, return False
-        if not isinstance(other, ObjectEntry):
-            return False
-
-        return (
-            self.variable_name == other.variable_name
-            and self.object == other.object
-            and self.description == other.description
-            and self.coop_info == other.coop_info
-            and self.created_at == other.created_at
-            and self.edsl_class_name == other.edsl_class_name
-        )
-
-
-if __name__ == "__main__":
-    from edsl import QuestionFreeText
-    from edsl.study import ObjectEntry
-
-    q = QuestionFreeText.example()
-
-    oe = ObjectEntry("q", q, "This is a question")
-    d = oe.to_dict()
-    new_oe = ObjectEntry.from_dict(d)
-    new_oe == oe

edsl/study/ProofOfWork.py

@@ -1,113 +0,0 @@
-import hashlib
-import time
-from typing import Any, Dict, List, Optional
-
-
-class ProofOfWork:
-    def __init__(
-        self,
-        input_data: Optional[Any] = None,
-        proof: Optional[Dict[int, List[Dict[str, Any]]]] = None,
-    ):
-        self.input_data = input_data
-        self.proof = proof or {}
-
-    def add_input_data(self, input_data: Any) -> None:
-        self.input_data = input_data
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "input_data": self.input_data,
-            "proof": self.proof,
-        }
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "ProofOfWork":
-        return cls(data["input_data"], data["proof"])
-
-    def __repr__(self) -> str:
-        return f"ProofOfWork(input_data={self.input_data}, proof={self.proof})"
-
-    def to_hash(self, nonce: int) -> str:
-        """
-        Hash the input data combined with the nonce.
-
-        Returns:
-        str: The resulting hash.
-        """
-        hash_input = self.input_data + str(nonce)
-        return hashlib.md5(hash_input.encode()).hexdigest()
-
-    def verify_work(self) -> bool:
-        for difficulty in self.proof:
-            for proof in self.proof[difficulty]:
-                nonce = proof["nonce"]
-                hash_result = self.to_hash(nonce)
-                prefix = "0" * difficulty
-                if not hash_result.startswith(prefix):
-                    return False
-                if hash_result != proof["hash"]:
-                    return False
-        return True
-
-    def add_proof(self, difficulty: int, starting_nonce: Optional[int] = None) -> None:
-        """
-        Find a nonce that results in a hash with `difficulty` number of leading zeros.
-
-        Returns:
-        int, str: The nonce that solves the proof of work and the resulting hash.
-        """
-        # Convert the difficulty into a string of zeros for comparison
-        prefix = "0" * difficulty
-        if not starting_nonce:
-            import random
-
-            starting_nonce = random.randint(0, 1000000)
-        nonce = starting_nonce
-        start = time.time()
-        while True:
-            # Combine the input data with the nonce and hash it
-            hash_result = self.to_hash(nonce)
-
-            # Check if the hash meets the difficulty requirement
-            if hash_result.startswith(prefix):
-                cycles = nonce - starting_nonce
-                end = time.time()
-                if difficulty in self.proof:
-                    self.proof[difficulty].append(
-                        {
-                            "nonce": nonce,
-                            "hash": hash_result,
-                            "time": end - start,
-                            "cycles": cycles,
-                        }
-                    )
-                else:
-                    self.proof[difficulty] = [
-                        {
-                            "nonce": nonce,
-                            "hash": hash_result,
-                            "time": end - start,
-                            "cycles": cycles,
-                        }
-                    ]
-                return
-
-            nonce += 1
-
-
-if __name__ == "__main__":
-    from edsl.study import ProofOfWork
-
-    p = ProofOfWork("hello world")
-    p.add_proof(3)
-    print(p)
-    p.add_proof(6)
-    print(p)
-
-    # Takes about a minute to run
-    p.add_proof(7)
-    print(p)
-
-    ok = p.verify_work()
-    print(ok)

edsl/study/SnapShot.py

@@ -1,80 +0,0 @@
-import inspect
-from typing import Generator, List, Optional
-
-
-class SnapShot:
-    def __init__(self, namespace, exclude: Optional[List] = None):
-        self.namespace = namespace
-        self.exclude = exclude or []
-        self.edsl_objects = dict(self._get_edsl_objects(namespace=self.namespace))
-        self.edsl_classes = dict(self._get_edsl_classes(namespace=self.namespace))
-
-    def _all_object_keys(self):
-        return self.namespace.keys()
-
-    def __repr__(self):
-        return f"SnapShot(edsl_objects={self.edsl_objects}, edsl_classes={self.edsl_objects})"
-
-    def _get_edsl_classes(
-        self, namespace: dict
-    ) -> Generator[tuple[str, type], None, None]:
-        """Get all EDSL classes in the namespace.
-
-        :param namespace: The namespace to search for EDSL classes. The default is the global namespace.
-
-        >>> sn = SnapShot(namespace = {})
-        >>> sn.edsl_classes
-        {}
-
-        >>> from edsl.caching import Cache
-        >>> sn = SnapShot(namespace = globals())
-        >>> sn.edsl_classes
-        {'Cache': <class 'edsl.caching.cache.Cache'>}
-        """
-        from ..base import RegisterSubclassesMeta
-        from ..questions import QuestionBase
-
-        all_edsl_objects = RegisterSubclassesMeta.get_registry()
-
-        for name, value in namespace.items():
-            if (
-                inspect.isclass(value)
-                and name in all_edsl_objects
-                and value != RegisterSubclassesMeta
-            ):
-                yield name, value
-            if inspect.isclass(value) and issubclass(value, QuestionBase):
-                yield name, value
-
-    def _get_edsl_objects(self, namespace) -> Generator[tuple[str, type], None, None]:
-        """Get all EDSL objects in the global namespace.
-
-        >>> sn = SnapShot(namespace = globals())
-        >>> sn.edsl_objects
-        {}
-
-        """
-        from edsl.base import Base
-        from edsl.study.Study import Study
-
-        def is_edsl_object(obj):
-            package_name = "edsl"
-            cls = obj.__class__
-            module_name = cls.__module__
-            return module_name.startswith(package_name)
-
-        for name, value in namespace.items():
-            # TODO check this code logic (if there are other objects with to_dict method that are not from edsl)
-            if (
-                is_edsl_object(value)
-                and hasattr(value, "to_dict")
-                and not inspect.isclass(value)
-                and value.__class__ not in [o.__class__ for o in self.exclude]
-            ):
-                yield name, value
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)