edsl 0.1.36.dev7__py3-none-any.whl → 0.1.37.dev1__py3-none-any.whl

edsl/jobs/interviews/InterviewStatistic.py

@@ -1,63 +1,63 @@
-import asyncio
-from enum import Enum
-from typing import Literal, List, Type, DefaultDict
-from collections import UserDict, defaultdict
-
-from edsl.jobs.interviews.InterviewStatusDictionary import InterviewStatusDictionary
-from edsl.jobs.tokens.InterviewTokenUsage import InterviewTokenUsage
-from edsl.enums import pricing, TokenPricing
-from edsl.jobs.tasks.task_status_enum import TaskStatus
-
-InterviewTokenUsageMapping = DefaultDict[str, InterviewTokenUsage]
-
-
-class InterviewStatistic(UserDict):
-    @staticmethod
-    def _format_number(number, digits=0, units=""):
-        """Format a number.
-
-        :param number: the number to format
-        :param digits: the number of digits to display
-        :param units: the units to display
-
-        Example usage:
-
-        >>> InterviewStatistic._format_number(1000, 1, "sec.")
-        '1,000.0 sec.'
-        """
-        if type(number) == str:
-            return number
-        else:
-            return f"{number:,.{digits}f}" + " " + units
-
-    @property
-    def _pretty_name(self):
-        """Return a pretty name for the statistic.
-
-        Example usage:
-
-        >>> InterviewStatistic("elapsed_time", value=100, digits=1, units="sec.").pretty_name
-        'Elapsed time'
-        """
-        return self.name.replace("_", " ").capitalize()
-
-    def __init__(
-        self,
-        name: str,
-        value: float,
-        digits: int = 0,
-        units: str = "",
-        pretty_name: str = None,
-    ):
-        """Create a new InterviewStatistic object."""
-        self.name = name
-        self.value = value
-        self.digits = digits
-        self.units = units
-        self.pretty_name = pretty_name or self._pretty_name
-
-        super().__init__(
-            {self.pretty_name: self._format_number(self.value, self.digits, self.units)}
-        )
-
-        self.raw: dict = {self.name: self.value}
+import asyncio
+from enum import Enum
+from typing import Literal, List, Type, DefaultDict
+from collections import UserDict, defaultdict
+
+from edsl.jobs.interviews.InterviewStatusDictionary import InterviewStatusDictionary
+from edsl.jobs.tokens.InterviewTokenUsage import InterviewTokenUsage
+from edsl.enums import pricing, TokenPricing
+from edsl.jobs.tasks.task_status_enum import TaskStatus
+
+InterviewTokenUsageMapping = DefaultDict[str, InterviewTokenUsage]
+
+
+class InterviewStatistic(UserDict):
+    @staticmethod
+    def _format_number(number, digits=0, units=""):
+        """Format a number.
+
+        :param number: the number to format
+        :param digits: the number of digits to display
+        :param units: the units to display
+
+        Example usage:
+
+        >>> InterviewStatistic._format_number(1000, 1, "sec.")
+        '1,000.0 sec.'
+        """
+        if type(number) == str:
+            return number
+        else:
+            return f"{number:,.{digits}f}" + " " + units
+
+    @property
+    def _pretty_name(self):
+        """Return a pretty name for the statistic.
+
+        Example usage:
+
+        >>> InterviewStatistic("elapsed_time", value=100, digits=1, units="sec.").pretty_name
+        'Elapsed time'
+        """
+        return self.name.replace("_", " ").capitalize()
+
+    def __init__(
+        self,
+        name: str,
+        value: float,
+        digits: int = 0,
+        units: str = "",
+        pretty_name: str = None,
+    ):
+        """Create a new InterviewStatistic object."""
+        self.name = name
+        self.value = value
+        self.digits = digits
+        self.units = units
+        self.pretty_name = pretty_name or self._pretty_name
+
+        super().__init__(
+            {self.pretty_name: self._format_number(self.value, self.digits, self.units)}
+        )
+
+        self.raw: dict = {self.name: self.value}

edsl/jobs/interviews/InterviewStatisticsCollection.py

@@ -1,25 +1,25 @@
-from collections import UserDict
-from edsl.jobs.interviews.InterviewStatistic import InterviewStatistic
-
-
-class InterviewStatisticsCollection(UserDict):
-    """A collection of interview statistics."""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.raw: dict = {}
-
-    def add_stat(self, statistic: InterviewStatistic):
-        """Add a statistic to the collection.
-
-        Each statistic is a dictionary with a single key-value pair.
-
-        Example usage:
-
-        >>> isc = InterviewStatisticsCollection()
-        >>> isc.add_stat(InterviewStatistic("elapsed_time", value=100, digits=1, units="sec."))
-        >>> isc.raw
-        {'elapsed_time': 100}
-        """
-        self.update(statistic)
-        self.raw.update(statistic.raw)
+from collections import UserDict
+from edsl.jobs.interviews.InterviewStatistic import InterviewStatistic
+
+
+class InterviewStatisticsCollection(UserDict):
+    """A collection of interview statistics."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.raw: dict = {}
+
+    def add_stat(self, statistic: InterviewStatistic):
+        """Add a statistic to the collection.
+
+        Each statistic is a dictionary with a single key-value pair.
+
+        Example usage:
+
+        >>> isc = InterviewStatisticsCollection()
+        >>> isc.add_stat(InterviewStatistic("elapsed_time", value=100, digits=1, units="sec."))
+        >>> isc.raw
+        {'elapsed_time': 100}
+        """
+        self.update(statistic)
+        self.raw.update(statistic.raw)

edsl/jobs/interviews/InterviewStatusDictionary.py

@@ -1,78 +1,78 @@
-from __future__ import annotations
-import json
-from collections import UserDict
-from typing import Union, Dict
-
-from edsl.jobs.tasks.task_status_enum import TaskStatus, get_enum_from_string
-
-
-class InterviewStatusDictionary(UserDict):
-    """A dictionary that keeps track of the status of all the tasks in an interview."""
-
-    def __init__(self, data: Union[Dict[TaskStatus, int], None] = None):
-        if data:
-            # checks to make sure every task status is in the enum
-            assert all([task_status in data for task_status in TaskStatus])
-            super().__init__(data)
-        else:
-            # sets all the task statuses to 0
-            d = {}
-            for task_status in TaskStatus:
-                d[task_status] = 0
-            d["number_from_cache"] = 0
-            super().__init__(d)
-
-    def __add__(
-        self, other: "InterviewStatusDictionary"
-    ) -> "InterviewStatusDictionary":
-        """Adds two InterviewStatusDictionaries together."""
-        if not isinstance(other, InterviewStatusDictionary):
-            raise ValueError(f"Can't add {type(other)} to InterviewStatusDictionary")
-        new_dict = {}
-        for key in self.keys():
-            new_dict[key] = self[key] + other[key]
-        return InterviewStatusDictionary(new_dict)
-
-    @property
-    def waiting(self) -> int:
-        """Return the number of tasks that are in a waiting status of some kind."""
-
-        waiting_status_list = [
-            TaskStatus.WAITING_FOR_REQUEST_CAPACITY,
-            TaskStatus.WAITING_FOR_TOKEN_CAPACITY,
-            TaskStatus.WAITING_FOR_DEPENDENCIES,
-        ]
-
-        return sum([self[status] for status in waiting_status_list])
-
-    def __repr__(self):
-        return f"InterviewStatusDictionary({self.data})"
-
-    def to_dict(self):
-        new_data = {str(key): value for key, value in self.data.items()}
-        return new_data
-
-    def print(self):
-        d = {}
-        for key, value in self.data.items():
-            d[str(key)] = value
-        from edsl.utilities.interface import print_dict_with_rich
-
-        print_dict_with_rich(d)
-
-    @classmethod
-    def from_dict(cls, data):
-        new_data = {get_enum_from_string(key): value for key, value in data.items()}
-        return cls(new_data)
-
-    def to_json(self):
-        import json
-
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, data):
-        import json
-
-        data = json.loads(data)
-        return cls.from_dict(data)
+from __future__ import annotations
+import json
+from collections import UserDict
+from typing import Union, Dict
+
+from edsl.jobs.tasks.task_status_enum import TaskStatus, get_enum_from_string
+
+
+class InterviewStatusDictionary(UserDict):
+    """A dictionary that keeps track of the status of all the tasks in an interview."""
+
+    def __init__(self, data: Union[Dict[TaskStatus, int], None] = None):
+        if data:
+            # checks to make sure every task status is in the enum
+            assert all([task_status in data for task_status in TaskStatus])
+            super().__init__(data)
+        else:
+            # sets all the task statuses to 0
+            d = {}
+            for task_status in TaskStatus:
+                d[task_status] = 0
+            d["number_from_cache"] = 0
+            super().__init__(d)
+
+    def __add__(
+        self, other: "InterviewStatusDictionary"
+    ) -> "InterviewStatusDictionary":
+        """Adds two InterviewStatusDictionaries together."""
+        if not isinstance(other, InterviewStatusDictionary):
+            raise ValueError(f"Can't add {type(other)} to InterviewStatusDictionary")
+        new_dict = {}
+        for key in self.keys():
+            new_dict[key] = self[key] + other[key]
+        return InterviewStatusDictionary(new_dict)
+
+    @property
+    def waiting(self) -> int:
+        """Return the number of tasks that are in a waiting status of some kind."""
+
+        waiting_status_list = [
+            TaskStatus.WAITING_FOR_REQUEST_CAPACITY,
+            TaskStatus.WAITING_FOR_TOKEN_CAPACITY,
+            TaskStatus.WAITING_FOR_DEPENDENCIES,
+        ]
+
+        return sum([self[status] for status in waiting_status_list])
+
+    def __repr__(self):
+        return f"InterviewStatusDictionary({self.data})"
+
+    def to_dict(self):
+        new_data = {str(key): value for key, value in self.data.items()}
+        return new_data
+
+    def print(self):
+        d = {}
+        for key, value in self.data.items():
+            d[str(key)] = value
+        from edsl.utilities.interface import print_dict_with_rich
+
+        print_dict_with_rich(d)
+
+    @classmethod
+    def from_dict(cls, data):
+        new_data = {get_enum_from_string(key): value for key, value in data.items()}
+        return cls(new_data)
+
+    def to_json(self):
+        import json
+
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, data):
+        import json
+
+        data = json.loads(data)
+        return cls.from_dict(data)

edsl/jobs/interviews/InterviewStatusLog.py

@@ -1,92 +1,92 @@
-from collections import UserDict
-
-from edsl.jobs.tasks.task_status_enum import TaskStatus, status_colors
-
-
-class InterviewStatusLog(UserDict):
-    """A dictionary of TaskStatusLog objects.
-
-    The key is the name of the task.
-    """
-
-    @property
-    def min_time(self):
-        return min([log.min_time for log in self.values()])
-
-    @property
-    def max_time(self):
-        return max([log.max_time for log in self.values()])
-
-    def status_matrix(self, num_periods):
-        """Return a matrix of status values."""
-        start_time = self.min_time
-        end_time = self.max_time
-        time_increment = (end_time - start_time) / num_periods
-        status_matrix = {}
-        time_periods = [start_time + i * time_increment for i in range(num_periods)]
-        for task_name, log in self.items():
-            status_matrix[task_name] = [log.status_at_time(t) for t in time_periods]
-        return status_matrix
-
-    def numerical_matrix(self, num_periods):
-        """Return a numerical matrix of status values."""
-        status_dicts = self.status_matrix(num_periods)
-
-        num_cols = num_periods
-        num_rows = len(status_dicts)
-        matrix = [[0 for _ in range(num_cols)] for _ in range(num_rows)]
-
-        for row_index, (task_name, status_list) in enumerate(status_dicts.items()):
-            matrix[row_index] = [
-                list(status_colors.keys()).index(status) for status in status_list
-            ]
-
-        index_to_names = {i: name for i, name in enumerate(status_dicts.keys())}
-        return matrix, index_to_names
-
-    def visualize(self, num_periods=10):
-        """Visualize the status matrix with outlined squares."""
-        import matplotlib.pyplot as plt
-        from matplotlib.colors import ListedColormap
-        import numpy as np
-        from matplotlib.patches import Rectangle
-
-        # Define your custom colormap
-        custom_cmap = ListedColormap(list(status_colors.values()))
-
-        # Generate the matrix
-        matrix, index_to_names = self.numerical_matrix(num_periods)
-
-        # Create the figure and axes
-        plt.figure(figsize=(10, 5))
-        ax = plt.gca()
-
-        # Display the matrix and keep a reference to the imshow object
-        im = ax.imshow(matrix, aspect="auto", cmap=custom_cmap)
-
-        # Adding color bar, now correctly associating it with 'im'
-        cbar = plt.colorbar(im, ticks=range(len(status_colors)), label="Task Status")
-
-        cbar_labels = [status.name for status in status_colors.keys()]
-        # breakpoint()
-        cbar.set_ticklabels(cbar_labels)  # Setting the custom labels for the colorbar
-
-        im.set_clim(
-            -0.5, len(status_colors) - 0.5
-        )  # Setting color limits directly on the imshow object
-
-        # Outline each cell by drawing rectangles
-        for (j, i), val in np.ndenumerate(matrix):
-            ax.add_patch(
-                Rectangle(
-                    (i - 0.5, j - 0.5), 1, 1, fill=False, edgecolor="black", lw=0.5
-                )
-            )
-
-        # Set custom y-axis ticks and labels
-        yticks = list(index_to_names.keys())
-        yticklabels = list(index_to_names.values())
-        plt.yticks(ticks=yticks, labels=yticklabels)
-
-        # Show the plot
-        plt.show()
+from collections import UserDict
+
+from edsl.jobs.tasks.task_status_enum import TaskStatus, status_colors
+
+
+class InterviewStatusLog(UserDict):
+    """A dictionary of TaskStatusLog objects.
+
+    The key is the name of the task.
+    """
+
+    @property
+    def min_time(self):
+        return min([log.min_time for log in self.values()])
+
+    @property
+    def max_time(self):
+        return max([log.max_time for log in self.values()])
+
+    def status_matrix(self, num_periods):
+        """Return a matrix of status values."""
+        start_time = self.min_time
+        end_time = self.max_time
+        time_increment = (end_time - start_time) / num_periods
+        status_matrix = {}
+        time_periods = [start_time + i * time_increment for i in range(num_periods)]
+        for task_name, log in self.items():
+            status_matrix[task_name] = [log.status_at_time(t) for t in time_periods]
+        return status_matrix
+
+    def numerical_matrix(self, num_periods):
+        """Return a numerical matrix of status values."""
+        status_dicts = self.status_matrix(num_periods)
+
+        num_cols = num_periods
+        num_rows = len(status_dicts)
+        matrix = [[0 for _ in range(num_cols)] for _ in range(num_rows)]
+
+        for row_index, (task_name, status_list) in enumerate(status_dicts.items()):
+            matrix[row_index] = [
+                list(status_colors.keys()).index(status) for status in status_list
+            ]
+
+        index_to_names = {i: name for i, name in enumerate(status_dicts.keys())}
+        return matrix, index_to_names
+
+    def visualize(self, num_periods=10):
+        """Visualize the status matrix with outlined squares."""
+        import matplotlib.pyplot as plt
+        from matplotlib.colors import ListedColormap
+        import numpy as np
+        from matplotlib.patches import Rectangle
+
+        # Define your custom colormap
+        custom_cmap = ListedColormap(list(status_colors.values()))
+
+        # Generate the matrix
+        matrix, index_to_names = self.numerical_matrix(num_periods)
+
+        # Create the figure and axes
+        plt.figure(figsize=(10, 5))
+        ax = plt.gca()
+
+        # Display the matrix and keep a reference to the imshow object
+        im = ax.imshow(matrix, aspect="auto", cmap=custom_cmap)
+
+        # Adding color bar, now correctly associating it with 'im'
+        cbar = plt.colorbar(im, ticks=range(len(status_colors)), label="Task Status")
+
+        cbar_labels = [status.name for status in status_colors.keys()]
+        # breakpoint()
+        cbar.set_ticklabels(cbar_labels)  # Setting the custom labels for the colorbar
+
+        im.set_clim(
+            -0.5, len(status_colors) - 0.5
+        )  # Setting color limits directly on the imshow object
+
+        # Outline each cell by drawing rectangles
+        for (j, i), val in np.ndenumerate(matrix):
+            ax.add_patch(
+                Rectangle(
+                    (i - 0.5, j - 0.5), 1, 1, fill=False, edgecolor="black", lw=0.5
+                )
+            )
+
+        # Set custom y-axis ticks and labels
+        yticks = list(index_to_names.keys())
+        yticklabels = list(index_to_names.values())
+        plt.yticks(ticks=yticks, labels=yticklabels)
+
+        # Show the plot
+        plt.show()

edsl/jobs/interviews/ReportErrors.py

@@ -1,66 +1,66 @@
-import json
-import requests
-import threading
-from edsl.coop import Coop
-
-
-class ReportErrors:
-    def __init__(self, task_history):
-        self.task_history = task_history
-        self.email = None
-
-    @property
-    def data(self):
-        return {
-            "text": self.task_history.to_dict(),
-            "email": self.email,
-        }
-
-    def get_email(self, timeout=10):
-        """Helper method to get user input with a timeout."""
-        input_queue = []
-
-        def input_thread_method():
-            email_input = input(
-                "Please enter your email address (if you want us to get in touch): "
-            )
-            input_queue.append(email_input)
-
-        input_thread = threading.Thread(target=input_thread_method)
-        input_thread.start()
-        input_thread.join(timeout=timeout)
-
-        if input_queue:
-            self.email = input_queue[0]
-        else:
-            print("No input received within the timeout period.")
-
-    def upload(self):
-        coop = Coop()
-        coop.error_create(error_data=self.data)
-
-
-def main():
-    from edsl.jobs.interviews.ReportErrors import ReportErrors
-
-    class TaskHistory:
-        def __init__(self, data):
-            self.data = data
-
-        def to_dict(self):
-            """Converts the internal data of the task history to a dictionary format."""
-            return self.data
-
-    task_history_data = {
-        "task": "Example Task",
-        "status": "Completed",
-        "details": "This is an example of a task history.",
-    }
-    task_history = TaskHistory(task_history_data)
-
-    reporter = ReportErrors(task_history)
-    # one without email
-    reporter.upload()
-    # one with email
-    reporter.email = "fake@gmail.com"
-    reporter.upload()
+import json
+import requests
+import threading
+from edsl.coop import Coop
+
+
+class ReportErrors:
+    def __init__(self, task_history):
+        self.task_history = task_history
+        self.email = None
+
+    @property
+    def data(self):
+        return {
+            "text": self.task_history.to_dict(),
+            "email": self.email,
+        }
+
+    def get_email(self, timeout=10):
+        """Helper method to get user input with a timeout."""
+        input_queue = []
+
+        def input_thread_method():
+            email_input = input(
+                "Please enter your email address (if you want us to get in touch): "
+            )
+            input_queue.append(email_input)
+
+        input_thread = threading.Thread(target=input_thread_method)
+        input_thread.start()
+        input_thread.join(timeout=timeout)
+
+        if input_queue:
+            self.email = input_queue[0]
+        else:
+            print("No input received within the timeout period.")
+
+    def upload(self):
+        # The previous implementation was removed because it relied on the old Coop ErrorModel
+        pass
+
+
+def main():
+    from edsl.jobs.interviews.ReportErrors import ReportErrors
+
+    class TaskHistory:
+        def __init__(self, data):
+            self.data = data
+
+        def to_dict(self):
+            """Converts the internal data of the task history to a dictionary format."""
+            return self.data
+
+    task_history_data = {
+        "task": "Example Task",
+        "status": "Completed",
+        "details": "This is an example of a task history.",
+    }
+    task_history = TaskHistory(task_history_data)
+
+    reporter = ReportErrors(task_history)
+    # one without email
+    reporter.upload()
+    # one with email
+    reporter.email = "fake@gmail.com"
+    reporter.upload()

edsl/jobs/interviews/interview_status_enum.py

@@ -1,9 +1,9 @@
-import enum
-
-
-class InterviewStatus(enum.Enum):
-    "These are the possible states an interview can be in."
-    NOT_STARTED = enum.auto()
-    SUCCESS = enum.auto()
-    WAITING_FOR_RESOURCES = enum.auto()
-    FAILED = enum.auto()
+import enum
+
+
+class InterviewStatus(enum.Enum):
+    "These are the possible states an interview can be in."
+    NOT_STARTED = enum.auto()
+    SUCCESS = enum.auto()
+    WAITING_FOR_RESOURCES = enum.auto()
+    FAILED = enum.auto()