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

edsl/results/ResultsDBMixin.py

@@ -1,184 +0,0 @@
-import pandas as pd
-import sqlite3
-from sqlalchemy import create_engine
-from enum import Enum
-
-
-class SQLDataShape(Enum):
-    WIDE = "wide"
-    LONG = "long"
-
-
-class ResultsDBMixin:
-    def rows(self):
-        for index, result in enumerate(self):
-            yield from result.rows(index)
-
-    def export_sql_dump(self, shape, filename):
-        shape_enum = self._get_shape_enum(shape)
-        conn = self.db(shape=shape_enum)
-
-        # Open file to write SQL dump
-        with open(filename, "w") as f:
-            for line in conn.iterdump():
-                f.write(f"{line}\n")
-
-        # Close the connection
-        conn.close()
-
-    def backup_db_to_file(self, shape, filename):
-        shape_enum = self._get_shape_enum(shape)
-        # Source database connection (in-memory)
-        source_conn = self.db(shape=shape_enum)
-
-        # Destination database connection (file)
-        dest_conn = sqlite3.connect(filename)
-
-        # Backup in-memory database to file
-        with source_conn:
-            source_conn.backup(dest_conn)
-
-        # Close both connections
-        source_conn.close()
-        dest_conn.close()
-
-    def db(self, shape: SQLDataShape, remove_prefix=False):
-        if shape == SQLDataShape.LONG:
-            # Step 2: Create a SQLite Database in Memory
-            conn = sqlite3.connect(":memory:")
-
-            create_table_query = """
-            CREATE TABLE self (
-                id INTEGER,
-                data_type TEXT,
-                key TEXT, 
-                value TEXT
-            )
-            """
-            conn.execute(create_table_query)
-
-            # # Step 3: Insert the tuples into the table
-            list_of_tuples = list(self.rows())
-            insert_query = (
-                "INSERT INTO self (id, data_type, key, value) VALUES (?, ?, ?, ?)"
-            )
-            conn.executemany(insert_query, list_of_tuples)
-            conn.commit()
-            return conn
-        elif shape == SQLDataShape.WIDE:
-            db_uri = "sqlite:///:memory:"
-
-            # Create SQLAlchemy engine with the in-memory database connection string
-            engine = create_engine(db_uri)
-
-            # Convert DataFrame to SQLite in-memory database
-            df = self.to_pandas(remove_prefix=remove_prefix)
-            df.to_sql("self", engine, index=False, if_exists="replace")
-
-            # Create a connection to the SQLite database
-            conn = engine.connect()
-            return conn
-        else:
-            raise Exception("Invalid SQLDataShape")
-
-    def _get_shape_enum(self, shape: str):
-        if shape is None:
-            raise Exception("Must select either 'wide' or 'long' format")
-        elif shape == "wide":
-            return SQLDataShape.WIDE
-        elif shape == "long":
-            return SQLDataShape.LONG
-        else:
-            raise Exception("Invalid shape: must be either 'long' or 'wide'")
-
-    def sql(
-        self,
-        query: str,
-        shape: str,
-        remove_prefix: bool = False,
-        transpose: bool = None,
-        transpose_by: str = None,
-        csv: bool = False,
-    ):
-        """Execute a SQL query and return the results as a DataFrame.
-        :param query: The SQL query to execute
-        :param transpose: Transpose the DataFrame if True
-        :param transpose_by: Column to use as the index when transposing, otherwise the first column
-        :param csv: Return the DataFrame as a CSV string if True
-        """
-        shape_enum = self._get_shape_enum(shape)
-
-        conn = self.db(shape=shape_enum, remove_prefix=remove_prefix)
-        df = pd.read_sql_query(query, conn)
-
-        # Transpose the DataFrame if transpose is True
-        if transpose or transpose_by:
-            df = pd.DataFrame(df)
-            if transpose_by:
-                df = df.set_index(transpose_by)
-            else:
-                df = df.set_index(df.columns[0])
-            df = df.transpose()
-
-        # Return as CSV if output is "csv"
-        if csv:
-            return df.to_csv(index=False)
-        else:
-            return df
-
-    def show_schema(self, shape: str, remove_prefix: bool = False):
-        shape_enum = self._get_shape_enum(shape)
-        conn = self.db(shape=shape_enum, remove_prefix=remove_prefix)
-
-        if shape_enum == SQLDataShape.LONG:
-            # Query to get the schema of all tables
-            query = "SELECT type, name, sql FROM sqlite_master WHERE type='table'"
-
-            # Execute the query
-            cursor = conn.execute(query)
-            schema = cursor.fetchall()
-
-            # Close the connection
-            conn.close()
-
-            # Format and return the schema information
-            schema_info = ""
-            for row in schema:
-                schema_info += f"Type: {row[0]}, Name: {row[1]}, SQL: {row[2]}\n"
-
-            print(schema_info)
-        elif shape_enum == SQLDataShape.WIDE:
-            query = f"PRAGMA table_info(self)"
-            schema = pd.read_sql(query, conn)
-            print(schema)
-
-
-if __name__ == "__main__":
-    from edsl.results import Results
-
-    r = Results.example()
-
-    df = r.sql(
-        "select data_type, key, value from self where data_type = 'answer'",
-        shape="long",
-    )
-    print(df)
-
-    df = r.sql(
-        "select * from self",
-        shape="wide",
-    )
-
-    df = r.sql(
-        "select * from self",
-        shape="wide",
-    )
-
-    r.show_schema(shape="long")
-
-    df = r.sql(
-        "select * from self",
-        shape="wide",
-    )
-
-    print(df)

edsl/surveys/SurveyFlowVisualizationMixin.py

@@ -1,92 +0,0 @@
-import pydot
-import tempfile
-from IPython.display import Image
-from edsl.utilities import is_notebook
-from edsl.surveys.base import RulePriority, EndOfSurvey
-
-
-class SurveyFlowVisualizationMixin:
-    def show_flow(self):
-        "Creates an image showing the flow of users through the survey."
-        # Create a graph object
-        graph = pydot.Dot(graph_type="digraph")
-
-        # Add nodes
-        for index, question in enumerate(self.questions):
-            graph.add_node(
-                pydot.Node(
-                    f"Q{index}", label=f"{question.question_name}", shape="ellipse"
-                )
-            )
-
-        # Add an "EndOfSurvey" node
-        graph.add_node(
-            pydot.Node("EndOfSurvey", label="End of Survey", shape="rectangle")
-        )
-
-        # Add edges for normal flow
-        num_questions = len(self.questions)
-        for index in range(num_questions - 1):  # From Q1 to Q3
-            graph.add_edge(pydot.Edge(f"Q{index}", f"Q{index+1}"))
-
-        graph.add_edge(pydot.Edge(f"Q{num_questions-1}", "EndOfSurvey"))
-
-        relevant_rules = [
-            rule
-            for rule in self.rule_collection
-            if rule.priority > RulePriority.DEFAULT.value
-        ]
-
-        colors = [
-            "blue",
-            "red",
-            "purple",
-            "orange",
-            "pink",
-            "brown",
-            "grey",
-            "cyan",
-            "green",
-        ]
-        rule_colors = {
-            rule: colors[i % len(colors)] for i, rule in enumerate(relevant_rules)
-        }
-
-        for rule in relevant_rules:
-            color = rule_colors[rule]
-            edge_label = f"if {rule.expression}"
-            source_node = f"Q{rule.current_q}"
-            target_node = (
-                f"Q{rule.next_q}" if rule.next_q != EndOfSurvey else "EndOfSurvey"
-            )
-            edge = pydot.Edge(
-                source_node, target_node, label=edge_label, color=color, fontcolor=color
-            )
-            graph.add_edge(edge)
-
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_file:
-            try:
-                graph.write_png(tmp_file.name)
-            except FileNotFoundError:
-                print(
-                    """File not found. Most likely it's because you don't have graphviz installed. Please install it and try again.
-                        It's 
-                        $ sudo apt-get install graphviz 
-                        on Ubuntu.
-                    """
-                )
-
-            if is_notebook():
-                display(Image(tmp_file.name))
-            else:
-                import os
-                import sys
-
-                if os.name == "nt":  # Windows
-                    os.system(f"start {tmp_file.name}")
-                elif os.name == "posix":  # macOS, Linux, Unix, etc.
-                    os.system(
-                        f"open {tmp_file.name}"
-                        if sys.platform == "darwin"
-                        else f"xdg-open {tmp_file.name}"
-                    )

edsl/trackers/Tracker.py

@@ -1,91 +0,0 @@
-"""
-This an ABC for a tracker that monitors a Python queue. 
-
-Contained within the namespace is a class called TrackerEvent, which is also an ABC. 
-This is the kind of event that will be placed in the queue the tracker is monitoring.
-Each child class of TrackerEvent needs to know how to update the state of the tracker.
-
-Each child has to implement a tracked_values method which tells what values the 
-tracker is tracking - this is so it can pretty-print them. 
-
-All child classes have to implement an allowed_events class variable. 
-
-"""
-import time
-from abc import ABC, abstractmethod
-from queue import Empty
-from edsl.utilities.interface import print_dict_with_rich
-
-
-class Tracker(ABC):
-    "Meant to be single-threaded"
-
-    class TrackerEvent(ABC):
-        "Each child event needs to know how to update the state of the tracker."
-
-        @abstractmethod
-        def apply(self, tracker):
-            pass
-
-    def __init__(self, event_queue, verbose=False):
-        self.event_queue = event_queue
-        self.observed_events = []
-        self.verbose = verbose
-        if self.verbose:
-            print("Tracker instantiated")
-
-    @abstractmethod
-    def allowed_events(self) -> set:
-        "What events (classes) are allowed to be placed in the queue?"
-        pass
-
-    @abstractmethod
-    def tracked_values(self) -> dict:
-        "What values are tracked by this tracker (should be flat dictionary)?"
-        pass
-
-    def get_from_queue(self):
-        """Gets events from the queue and stores them in a list.
-        It runs until the event_queue is empty.
-        """
-        while True:
-            try:
-                event = self.event_queue.get(block=False)
-            except Empty as e:
-                if self.verbose:
-                    print("The queue is empty.")
-                break
-            else:
-                self.observed_events.append(event)
-                self.process_event(event)
-                self.event_queue.task_done()
-
-    def __call__(self, all_done, interval=1):
-        if self.verbose:
-            print("Tracking thread is starting.")
-        while not all_done.is_set():
-            self.get_from_queue()
-            time.sleep(interval)
-
-        # Run one last time to get anything still left in the event_queue
-        self.get_from_queue()
-
-    def process_event(self, event):
-        """Processes an event from the event queue."""
-
-        ## diabling this for now as two error-prone:
-        # https://chat.openai.com/share/6e0e2ae2-30d7-4281-982a-a69a218c4e76
-
-        # if not isinstance(event, tuple(self.allowed_events())):
-        #    print(f"Event type: {type(event).__name__}")
-        #    print(f"Allowed events: {self.allowed_events()}")
-        #    raise ValueError(f"Invalid event type: {type(event).__name__}")
-
-        event.apply(self)
-        if self.verbose:
-            self.show_status()
-
-    def show_status(self):
-        """Prints the status of the interview manager."""
-        data = self.tracked_values()
-        print_dict_with_rich(data)

edsl/trackers/TrackerAPI.py

@@ -1,196 +0,0 @@
-"""This tracker tracks API calls."""
-import json
-import time
-from collections import namedtuple
-from threading import Lock, Event
-from edsl.trackers.Tracker import Tracker
-
-UsageRates = namedtuple(
-    "UsageRates",
-    [
-        "estimated_tokens_per_minute_k",
-        "pct_of_tpm_limit",
-        "estimated_requests_per_minute_k",
-        "pct_of_rpm_limit",
-    ],
-)
-
-
-class TrackerAPI(Tracker):
-    """ """
-
-    class APICallDetails(Tracker.TrackerEvent):
-        def __init__(self, details):
-            self.details = details
-
-        def apply(self, tracker):
-            with tracker.lock:
-                tracker.usage.append(self.details)
-
-    def __init__(
-        self, lock, monitored_queue, tokens_per_minute_k=90, requests_per_minute_k=2
-    ):
-        self.lock = lock
-        self.tokens_per_minute_k = tokens_per_minute_k
-        self.requests_per_minute_k = requests_per_minute_k
-        self.usage = []
-
-        super().__init__(monitored_queue)
-
-    def usage_rates(self, last_seconds=60):
-        with self.lock:
-            right_now = time.time()
-            relevant_usage = [
-                x
-                for x in self.usage
-                if (x["timestamp"] > right_now - last_seconds)
-                and not x["cached_response"]
-            ]
-            if relevant_usage == []:
-                return UsageRates(**{k: 0 for k in UsageRates._fields})
-            else:
-                elapsed_seconds = right_now - relevant_usage[0]["timestamp"]
-                total_tokens = sum([x["total_tokens"] for x in relevant_usage])
-
-                estimated_tokens_per_minute_k = round(
-                    total_tokens / (elapsed_seconds / 60.0) / 1000, 0
-                )
-                pct_of_tpm_limit = round(
-                    100 * estimated_tokens_per_minute_k / self.tokens_per_minute_k
-                )
-
-                estimated_requests_per_minute_k = round(
-                    len(relevant_usage) / (elapsed_seconds / 60.0) / 1000, 2
-                )
-                pct_of_rpm_limit = round(
-                    100 * estimated_requests_per_minute_k / self.requests_per_minute_k
-                )
-
-                usage_rates = UsageRates(
-                    estimated_tokens_per_minute_k=estimated_tokens_per_minute_k,
-                    pct_of_tpm_limit=pct_of_tpm_limit,
-                    estimated_requests_per_minute_k=estimated_requests_per_minute_k,
-                    pct_of_rpm_limit=pct_of_rpm_limit,
-                )
-
-                return usage_rates
-
-    def tracked_values(self) -> dict:
-        return {
-            "Calls": len(self.usage),
-        }
-
-    def allowed_events(self):
-        return set([TrackerAPI.APICallDetails])
-
-    @classmethod
-    def fromJSON(cls, filename):
-        """This loads a tracker from a JSON file. Just for testing purposes"""
-        with open(filename, "r") as f:
-            json_dict = f.read()
-        usage = json.loads(json_dict)
-        # pretend responses are not cached for each testing, as the
-        # usage_rate methods only compute w/ non-cached responses
-        [x.update({"cached_response": False}) for x in usage]
-        instance = cls(Lock(), None)
-        instance.usage = usage
-        return instance
-
-    def toJSON(self, filename="sample_data.json"):
-        with open(filename, "w") as f:
-            json.dump(self.usage, f)
-
-    def status(self):
-        """This prints the status of the interview manager, while interviews are doing on."""
-        estimated_length = 100
-        completed = self.status_tracker.complete
-        pct_completed = self.status_tracker.percentage_complete
-        usage_rates = self.current_tpm(10)
-        heartbeat = next(self.status_tracker.hearbeat)
-        status_str = (
-            f"{heartbeat} Completed: {completed} ({pct_completed} of total); "
-            f"Est. TPM (k): {usage_rates.estimated_tokens_per_minute_k: ,} ({usage_rates.frac_of_tpm_limit}% of lim.); "
-            f"Est. RPM (k): {usage_rates.estimated_requests_per_minute_k:,} ({usage_rates.frac_of_rpm_limit}% of lim.)); "
-        )
-        # Pad with spaces to reach the estimated length
-        padded_status_str = status_str.ljust(estimated_length)
-        print(f"\r{padded_status_str}", end="", flush=True)
-
-
-if __name__ == "__main__":
-    import textwrap
-    from language_models import LanguageModelOpenAIThreeFiveTurbo
-
-    m = LanguageModelOpenAIThreeFiveTurbo(use_cache=True)
-
-    # the language model is attached to the queue
-    print(m.api_queue)
-
-    # the tracker expects a lock and an event
-    lock = Lock()
-    all_done = Event()
-
-    # tracker attached to the queue
-    tracker = TrackerAPI(lock=lock, monitored_queue=m.api_queue)
-
-    # the queue is empty to start
-    print(f"Queue size: {m.api_queue.qsize()}")
-
-    # a call is made to the language model
-    raw = m.get_raw_response(
-        prompt="What is your favorite color?",
-        system_prompt=textwrap.dedent(
-            """\
-                            You are pretending to be a human taking a survey.
-                            Do not break character. 
-                            """
-        ),
-    )
-
-    # sleep for a second, as queue puts are non-blocking
-    import time
-
-    print("Sleeping for 1 second")
-    time.sleep(1)
-    # see that the queue updated
-    print(f"Queue size: {m.api_queue.qsize()}")
-    print(m.parse_response(raw))
-    # indicate we are all done
-    all_done.set()
-    # have the tracker finish up
-    tracker(all_done, interval=1)
-    # how many calls did the API observe?
-    print(tracker.tracked_values())
-    # what is in the tracker queue?
-    print(tracker.usage)
-    # confirm that the API queue is empty
-    print(f"Queue size: {m.api_queue.qsize()}")
-
-    ## Next example - compute queue statistics
-    all_done = Event()
-
-    tracker_two = TrackerAPI(lock=lock, monitored_queue=m.api_queue)
-
-    for i in range(10):
-        raw = m.get_raw_response(
-            prompt=f"What emotions are associated with {i}?",
-            system_prompt=textwrap.dedent(
-                """\
-                                You are pretending to be a human taking a survey.
-                                Do not break character. 
-                                """
-            ),
-        )
-
-    time.sleep(1)
-    all_done.set()
-    # have the tracker finish up
-    tracker(all_done, interval=1)
-    # print(tracker.usage)
-    tracker.toJSON(filename="sample_data.json")
-
-    # from .example_api_call_data import sample_data
-    tracker = TrackerAPI.fromJSON("sample_data.json")
-    print(tracker.usage)
-
-    print(tracker.usage_rates(1000000))

edsl/trackers/TrackerTasks.py

@@ -1,70 +0,0 @@
-from edsl.trackers.Tracker import Tracker
-from edsl.utilities.interface import heartbeat_generator, human_readable_labeler_creator
-
-
-class TrackerTasks(Tracker):
-    """ """
-
-    class WorkerActivated(Tracker.TrackerEvent):
-        def apply(self, tracker):
-            with tracker.lock:
-                tracker.active_workers += 1
-
-    class WorkerDeactivated(Tracker.TrackerEvent):
-        def apply(self, tracker):
-            with tracker.lock:
-                tracker.active_workers -= 1
-
-    class TaskStarted(Tracker.TrackerEvent):
-        def apply(self, tracker):
-            with tracker.lock:
-                tracker.interviews_started += 1
-
-    class TaskCompleted(Tracker.TrackerEvent):
-        def apply(self, tracker):
-            with tracker.lock:
-                tracker.interviews_completed += 1
-
-    class ThreadStatus(Tracker.TrackerEvent):
-        def __init__(self, thread_id, status):
-            self.thread_id = thread_id
-            self.status = status
-
-        def apply(self, tracker):
-            with tracker.lock:
-                tracker.thread_status[self.thread_id] = self.status
-
-    def __init__(self, num_interviews, lock, monitored_queue):
-        self.num_interviews = num_interviews  # how many interviews are there in total
-        self.lock = lock
-        self.hearbeat = heartbeat_generator()  # generator to show responses coming in
-        self.active_workers = 0
-        self.interviews_started = 0
-        self.interviews_completed = 0
-        self.thread_status = dict()
-        # this is a function that takes thread IDs and turns them into successive integers
-        self.human_readable_labeler = human_readable_labeler_creator()
-
-        super().__init__(monitored_queue)
-
-    def tracked_values(self) -> dict:
-        return {
-            "Active Workers": self.active_workers,
-            "Interviews Started": self.interviews_started,
-            "Completed Interviews": self.interviews_completed,
-        }
-
-    def allowed_events(self):
-        return set(
-            [
-                TrackerTasks.WorkerActivated,
-                TrackerTasks.WorkerDeactivated,
-                TrackerTasks.TaskStarted,
-                TrackerTasks.TaskCompleted,
-                TrackerTasks.ThreadStatus,
-            ]
-        )
-
-    @property
-    def percentage_complete(self):
-        return round(100 * self.interviews_completed / self.num_interviews, 2)