edsl 0.1.39.dev3__py3-none-any.whl → 0.1.39.dev4__py3-none-any.whl

edsl/language_models/registry.py

@@ -1,190 +0,0 @@
-import textwrap
-from random import random
-from edsl.config import CONFIG
-
-# if "EDSL_DEFAULT_MODEL" not in CONFIG:
-#     default_model = "test"
-# else:
-#     default_model = CONFIG.get("EDSL_DEFAULT_MODEL")
-
-from collections import UserList
-
-
-class PrettyList(UserList):
-    def __init__(self, data=None, columns=None):
-        super().__init__(data)
-        self.columns = columns
-
-    def _repr_html_(self):
-        if isinstance(self[0], list) or isinstance(self[0], tuple):
-            num_cols = len(self[0])
-        else:
-            num_cols = 1
-
-        if self.columns:
-            columns = self.columns
-        else:
-            columns = list(range(num_cols))
-
-        if num_cols > 1:
-            return (
-                "<pre><table>"
-                + "".join(["<th>" + str(column) + "</th>" for column in columns])
-                + "".join(
-                    [
-                        "<tr>"
-                        + "".join(["<td>" + str(x) + "</td>" for x in row])
-                        + "</tr>"
-                        for row in self
-                    ]
-                )
-                + "</table></pre>"
-            )
-        else:
-            return (
-                "<pre><table>"
-                + "".join(["<th>" + str(index) + "</th>" for index in columns])
-                + "".join(
-                    ["<tr>" + "<td>" + str(row) + "</td>" + "</tr>" for row in self]
-                )
-                + "</table></pre>"
-            )
-
-
-def get_model_class(model_name, registry=None):
-    from edsl.inference_services.registry import default
-
-    registry = registry or default
-    factory = registry.create_model_factory(model_name)
-    return factory
-
-
-class Meta(type):
-    def __repr__(cls):
-        return textwrap.dedent(
-            f"""\
-        Available models: {cls.available()}
-        
-        To create an instance, you can do: 
-        >>> m = Model('gpt-4-1106-preview', temperature=0.5, ...)
-        
-        To get the default model, you can leave out the model name. 
-        To see the available models, you can do:
-        >>> Model.available()
-        """
-        )
-
-
-class Model(metaclass=Meta):
-    default_model = CONFIG.get("EDSL_DEFAULT_MODEL")
-
-    def __new__(
-        cls, model_name=None, registry=None, service_name=None, *args, **kwargs
-    ):
-        # Map index to the respective subclass
-        if model_name is None:
-            model_name = (
-                cls.default_model
-            )  # when model_name is None, use the default model, set in the config file
-        from edsl.inference_services.registry import default
-
-        registry = registry or default
-
-        if isinstance(model_name, int):  # can refer to a model by index
-            model_name = cls.available(name_only=True)[model_name]
-
-        factory = registry.create_model_factory(model_name, service_name=service_name)
-        return factory(*args, **kwargs)
-
-    @classmethod
-    def add_model(cls, service_name, model_name):
-        from edsl.inference_services.registry import default
-
-        registry = default
-        registry.add_model(service_name, model_name)
-
-    @classmethod
-    def services(cls, registry=None):
-        from edsl.inference_services.registry import default
-
-        registry = registry or default
-        return [r._inference_service_ for r in registry.services]
-
-    @classmethod
-    def available(cls, search_term=None, name_only=False, registry=None, service=None):
-        from edsl.inference_services.registry import default
-
-        registry = registry or default
-        full_list = registry.available()
-
-        if service is not None:
-            if service not in cls.services(registry=registry):
-                raise ValueError(f"Service {service} not found in available services.")
-
-            full_list = [m for m in full_list if m[1] == service]
-
-        if search_term is None:
-            if name_only:
-                return PrettyList(
-                    [m[0] for m in full_list],
-                    columns=["Model Name", "Service Name", "Code"],
-                )
-            else:
-                return PrettyList(
-                    full_list, columns=["Model Name", "Service Name", "Code"]
-                )
-        else:
-            filtered_results = [
-                m for m in full_list if search_term in m[0] or search_term in m[1]
-            ]
-            if name_only:
-                return PrettyList(
-                    [m[0] for m in filtered_results],
-                    columns=["Model Name", "Service Name", "Code"],
-                )
-            else:
-                return PrettyList(
-                    filtered_results, columns=["Model Name", "Service Name", "Code"]
-                )
-
-    @classmethod
-    def check_models(cls, verbose=False):
-        print("Checking all available models...\n")
-        for model in cls.available(name_only=True):
-            print(f"Now checking: {model}")
-            try:
-                m = cls(model)
-            except Exception as e:
-                print(f"Error creating instance of {model}: {e}")
-                continue
-            try:
-                results = m.hello(verbose)
-                if verbose:
-                    print(f"Results from model call: {results}")
-            except Exception as e:
-                print(f"Error calling 'hello' on {model}: {e}")
-                continue
-            print("OK!")
-            print("\n")
-
-    @classmethod
-    def example(cls, randomize: bool = False) -> "Model":
-        """
-        Returns an example Model instance.
-
-        :param randomize: If True, the temperature is set to a random decimal between 0 and 1.
-        """
-        temperature = 0.5 if not randomize else round(random(), 2)
-        model_name = cls.default_model
-        return cls(model_name, temperature=temperature)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
-
-    available = Model.available()
-    m = Model("gpt-4-1106-preview")
-    results = m.execute_model_call("Hello world")
-    print(results)

edsl/language_models/unused/ReplicateBase.py

@@ -1,83 +0,0 @@
-import asyncio
-import aiohttp
-import json
-from typing import Any
-
-from edsl import CONFIG
-
-from edsl.language_models.LanguageModel import LanguageModel
-
-
-def replicate_model_factory(model_name, base_url, api_token):
-    class ReplicateLanguageModelBase(LanguageModel):
-        _model_ = (
-            model_name  # Example model name, replace with actual model name if needed
-        )
-        _parameters_ = {
-            "temperature": 0.1,
-            "topK": 50,
-            "topP": 0.9,
-            "max_new_tokens": 500,
-            "min_new_tokens": -1,
-            "repetition_penalty": 1.15,
-            #       "version": "5fe0a3d7ac2852264a25279d1dfb798acbc4d49711d126646594e212cb821749",
-            "use_cache": True,
-        }
-        _api_token = api_token
-        _base_url = base_url
-
-        async def async_execute_model_call(
-            self, user_prompt: str, system_prompt: str = ""
-        ) -> dict[str, Any]:
-            self.api_token = self._api_token
-            self.headers = {
-                "Authorization": f"Token {self.api_token}",
-                "Content-Type": "application/json",
-            }
-            # combined_prompt = f"{system_prompt} {user_prompt}".strip()
-            # print(f"Prompt: {combined_prompt}")
-            data = {
-                #          "version": self._parameters_["version"],
-                "input": {
-                    "debug": False,
-                    "top_k": self._parameters_["topK"],
-                    "top_p": self._parameters_["topP"],
-                    "prompt": user_prompt,
-                    "system_prompt": system_prompt,
-                    "temperature": self._parameters_["temperature"],
-                    "max_new_tokens": self._parameters_["max_new_tokens"],
-                    "min_new_tokens": self._parameters_["min_new_tokens"],
-                    "prompt_template": "{prompt}",
-                    "repetition_penalty": self._parameters_["repetition_penalty"],
-                },
-            }
-
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    self._base_url, headers=self.headers, data=json.dumps(data)
-                ) as response:
-                    raw_response_text = await response.text()
-                    data = json.loads(raw_response_text)
-                    print(f"This was the data returned by the model:{data}")
-                    prediction_url = data["urls"]["get"]
-
-                while True:
-                    async with session.get(
-                        prediction_url, headers=self.headers
-                    ) as get_response:
-                        if get_response.status != 200:
-                            # Handle non-success status codes appropriately
-                            return None
-
-                        get_data = await get_response.text()
-                        get_data = json.loads(get_data)
-                        if get_data["status"] == "succeeded":
-                            return get_data
-                        await asyncio.sleep(1)
-
-        def parse_response(self, raw_response: dict[str, Any]) -> str:
-            data = "".join(raw_response["output"])
-            print(f"This is what the model returned: {data}")
-            return data
-
-    return ReplicateLanguageModelBase

edsl/results/ResultsDBMixin.py

@@ -1,238 +0,0 @@
-"""Mixin for working with SQLite respresentation of a 'Results' object."""
-
-import sqlite3
-from enum import Enum
-from typing import Literal, Union, Optional
-
-
-class SQLDataShape(Enum):
-    """Enum for the shape of the data in the SQL database."""
-
-    WIDE = "wide"
-    LONG = "long"
-
-
-class ResultsDBMixin:
-    """Mixin for interacting with a Results object as if it were a SQL database."""
-
-    def _rows(self):
-        """Return the rows of the `Results` object as a list of tuples."""
-        for index, result in enumerate(self):
-            yield from result.rows(index)
-
-    def export_sql_dump(self, shape: Literal["wide", "long"], filename: str):
-        """Export the SQL database to a file.
-
-        :param shape: The shape of the data in the database (wide or long)
-        :param filename: The filename to save the database to
-        """
-        shape_enum = self._get_shape_enum(shape)
-        conn = self._db(shape=shape_enum)
-
-        with open(filename, "w") as f:
-            for line in conn.iterdump():
-                f.write(f"{line}\n")
-
-        conn.close()
-
-    def backup_db_to_file(self, shape: Literal["wide", "long"], filename: str):
-        """Backup the in-memory database to a file.
-
-
-        :param shape: The shape of the data in the database (wide or long)
-        :param filename: The filename to save the database to
-
-        >>> from edsl.results import Results
-        >>> r = Results.example()
-        >>> r.backup_db_to_file(filename="backup.db", shape="long")
-
-        """
-        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):
-        """Create a SQLite database in memory and return the connection.
-
-        :param shape: The shape of the data in the database (wide or long)
-        :param remove_prefix: Whether to remove the prefix from the column names
-
-        """
-        if shape == SQLDataShape.LONG:
-            conn = sqlite3.connect(":memory:")
-
-            create_table_query = """
-            CREATE TABLE self (
-                id INTEGER,
-                data_type TEXT,
-                key TEXT, 
-                value TEXT
-            )
-            """
-            conn.execute(create_table_query)
-
-            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:
-            from sqlalchemy import create_engine
-
-            engine = create_engine("sqlite:///:memory:")
-            df = self.to_pandas(remove_prefix=remove_prefix, lists_as_strings=True)
-            df.to_sql("self", engine, index=False, if_exists="replace")
-            return engine.connect()
-        else:
-            raise Exception("Invalid SQLDataShape")
-
-    def _get_shape_enum(self, shape: Literal["wide", "long"]):
-        """Convert the shape string to a SQLDataShape enum."""
-        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: Literal["wide", "long"] = "wide",
-        remove_prefix: bool = True,
-        transpose: bool = None,
-        transpose_by: str = None,
-        csv: bool = False,
-        to_list=False,
-        to_latex=False,
-        filename: Optional[str] = None,
-    ) -> Union["pd.DataFrame", str]:
-        """Execute a SQL query and return the results as a DataFrame.
-
-        :param query: The SQL query to execute
-        :param shape: The shape of the data in the database (wide or long)
-        :param remove_prefix: Whether to remove the prefix from the column names
-        :param transpose: Whether to transpose the DataFrame
-        :param transpose_by: The column to use as the index when transposing
-        :param csv: Whether to return the DataFrame as a CSV string
-
-
-        Example usage:
-
-        >>> from edsl.results import Results
-        >>> r = Results.example()
-        >>> d = r.sql("select data_type, key, value from self where data_type = 'answer' order by value limit 3", shape="long")
-        >>> sorted(list(d['value']))
-        ['Good', 'Great', 'Great']
-
-        We can also return the data in wide format.
-        Note the use of single quotes to escape the column names, as required by sql.
-
-        >>> from edsl.results import Results
-        >>> Results.example().sql("select how_feeling from self", shape = 'wide', remove_prefix=True)
-          how_feeling
-        0          OK
-        1       Great
-        2    Terrible
-        3          OK
-        """
-        import pandas as pd
-
-        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()
-
-        if csv and to_list:
-            raise Exception("Cannot return both CSV and list")
-
-        if to_list:
-            return df.values.tolist()
-
-        if to_latex:
-            df.columns = [col.replace("_", " ") for col in df.columns]
-
-            latex_output = df.to_latex(index=False)
-            if filename:
-                with open(filename, "w") as f:
-                    f.write(latex_output)
-                return None
-            return latex_output
-
-        if csv:
-            if filename:
-                df.to_csv(filename, index=False)
-                return None
-
-            return df.to_csv(index=False)
-
-        return df
-
-    def show_schema(
-        self, shape: Literal["wide", "long"], remove_prefix: bool = False
-    ) -> None:
-        """Show the schema of the Results database.
-
-        :param shape: The shape of the data in the database (wide or long)
-        :param remove_prefix: Whether to remove the prefix from the column names
-
-        >>> from edsl.results import Results
-        >>> r = Results.example()
-        >>> r.show_schema(shape="long")
-        Type: table, Name: self, SQL: CREATE TABLE self (
-        ...
-        <BLANKLINE>
-        """
-        import pandas as pd
-
-        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'"
-            cursor = conn.execute(query)
-            schema = cursor.fetchall()
-            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)
-            return schema
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)