edsl 0.1.15__py3-none-any.whl → 0.1.40__py3-none-any.whl

edsl/scenarios/scenario_selector.py

@@ -0,0 +1,156 @@
+from typing import TYPE_CHECKING
+
+
+class ScenarioSelector:
+    """
+    A class for performing advanced field selection on ScenarioList objects,
+    including support for wildcard patterns.
+
+    Args:
+        scenario_list: The ScenarioList object to perform selections on
+
+    Examples:
+        >>> from edsl import Scenario, ScenarioList
+        >>> scenarios = ScenarioList([Scenario({'test_1': 1, 'test_2': 2, 'other': 3}), Scenario({'test_1': 4, 'test_2': 5, 'other': 6})])
+        >>> selector = ScenarioSelector(scenarios)
+        >>> selector.select('test*')
+        ScenarioList([Scenario({'test_1': 1, 'test_2': 2}), Scenario({'test_1': 4, 'test_2': 5})])
+    """
+
+    def __init__(self, scenario_list: "ScenarioList"):
+        """Initialize with a ScenarioList object."""
+        self.scenario_list = scenario_list
+        self.available_fields = (
+            list(scenario_list.data[0].keys()) if scenario_list.data else []
+        )
+
+    def _match_field_pattern(self, pattern: str, field: str) -> bool:
+        """
+        Checks if a field name matches a pattern with wildcards.
+        Supports '*' as wildcard at start or end of pattern.
+
+        Args:
+            pattern: The pattern to match against, may contain '*' at start or end
+            field: The field name to check
+
+        Examples:
+            >>> from edsl.scenarios import ScenarioList, Scenario
+            >>> selector = ScenarioSelector(ScenarioList([]))
+            >>> selector._match_field_pattern('test*', 'test_field')
+            True
+            >>> selector._match_field_pattern('*field', 'test_field')
+            True
+            >>> selector._match_field_pattern('test', 'test')
+            True
+            >>> selector._match_field_pattern('*test*', 'my_test_field')
+            True
+        """
+        if "*" not in pattern:
+            return pattern == field
+
+        if pattern.startswith("*") and pattern.endswith("*"):
+            return pattern[1:-1] in field
+        elif pattern.startswith("*"):
+            return field.endswith(pattern[1:])
+        elif pattern.endswith("*"):
+            return field.startswith(pattern[:-1])
+        return pattern == field
+
+    def _get_matching_fields(self, patterns: list[str]) -> list[str]:
+        """
+        Gets all fields that match any of the given patterns.
+
+        Args:
+            patterns: List of field patterns, may contain wildcards
+
+        Returns:
+            List of field names that match at least one pattern
+
+        Examples:
+            >>> from edsl import Scenario, ScenarioList
+            >>> scenarios = ScenarioList([
+            ...     Scenario({'test_1': 1, 'test_2': 2, 'other': 3})
+            ... ])
+            >>> selector = ScenarioSelector(scenarios)
+            >>> selector._get_matching_fields(['test*'])
+            ['test_1', 'test_2']
+        """
+        matching_fields = set()
+        for pattern in patterns:
+            matches = [
+                field
+                for field in self.available_fields
+                if self._match_field_pattern(pattern, field)
+            ]
+            matching_fields.update(matches)
+        return sorted(list(matching_fields))
+
+    def select(self, *fields) -> "ScenarioList":
+        """
+        Selects scenarios with only the referenced fields.
+        Supports wildcard patterns using '*' at the start or end of field names.
+
+        Args:
+            *fields: Field names or patterns to select. Patterns may include '*' for wildcards.
+
+        Returns:
+            A new ScenarioList containing only the matched fields.
+
+        Raises:
+            ValueError: If no fields match the given patterns.
+
+        Examples:
+            >>> from edsl import Scenario, ScenarioList
+            >>> scenarios = ScenarioList([
+            ...     Scenario({'test_1': 1, 'test_2': 2, 'other': 3}),
+            ...     Scenario({'test_1': 4, 'test_2': 5, 'other': 6})
+            ... ])
+            >>> selector = ScenarioSelector(scenarios)
+            >>> selector.select('test*')  # Selects all fields starting with 'test'
+            ScenarioList([Scenario({'test_1': 1, 'test_2': 2}), Scenario({'test_1': 4, 'test_2': 5})])
+            >>> selector.select('*_1')  # Selects all fields ending with '_1'
+            ScenarioList([Scenario({'test_1': 1}), Scenario({'test_1': 4})])
+            >>> selector.select('test_1', '*_2')  # Multiple patterns
+            ScenarioList([Scenario({'test_1': 1, 'test_2': 2}), Scenario({'test_1': 4, 'test_2': 5})])
+        """
+        if not self.scenario_list.data:
+            return self.scenario_list.__class__([])
+
+        # Convert single string to list for consistent processing
+        patterns = list(fields)
+
+        # Get all fields that match the patterns
+        fields_to_select = self._get_matching_fields(patterns)
+
+        # If no fields match, raise an informative error
+        if not fields_to_select:
+            raise ValueError(
+                f"No fields matched the given patterns: {patterns}. "
+                f"Available fields are: {self.available_fields}"
+            )
+
+        return self.scenario_list.__class__(
+            [scenario.select(fields_to_select) for scenario in self.scenario_list.data]
+        )
+
+    def get_available_fields(self) -> list[str]:
+        """
+        Returns a list of all available fields in the ScenarioList.
+
+        Returns:
+            List of field names available for selection.
+
+        Examples:
+            >>> from edsl import Scenario, ScenarioList
+            >>> scenarios = ScenarioList([Scenario({'test_1': 1, 'test_2': 2, 'other': 3})])
+            >>> selector = ScenarioSelector(scenarios)
+            >>> selector.get_available_fields()
+            ['other', 'test_1', 'test_2']
+        """
+        return sorted(self.available_fields)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/shared.py

@@ -0,0 +1 @@
+shared_globals = {}

edsl/study/ObjectEntry.py

@@ -0,0 +1,173 @@
+import time
+import webbrowser
+from typing import Any, Dict, Optional, Type
+from edsl.questions.QuestionBase 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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,80 @@
+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.data.Cache import Cache
+        >>> sn = SnapShot(namespace = globals())
+        >>> sn.edsl_classes
+        {'Cache': <class 'edsl.data.Cache.Cache'>}
+        """
+        from edsl.Base import RegisterSubclassesMeta
+        from edsl.questions.QuestionBase 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)