edsl 0.1.37.dev4__py3-none-any.whl → 0.1.37.dev5__py3-none-any.whl

edsl/language_models/fake_openai_service.py

@@ -1,61 +1,61 @@
-import threading
-import asyncio
-from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
-import uvicorn
-import json
-from typing import Any
-
-app = FastAPI()
-
-
-async def generate_response(question_number: int) -> dict:
-    # Simulate some asynchronous work
-    await asyncio.sleep(1)
-    return {
-        "id": "chatcmpl-123",
-        "object": "chat.completion",
-        "created": 1677652288,
-        "model": "gpt-3.5-turbo-0613",
-        "choices": [
-            {
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "content": json.dumps(
-                        {"answer": f"SPAM for question {question_number}!"}
-                    ),
-                },
-                "finish_reason": "stop",
-            }
-        ],
-        "usage": {"prompt_tokens": 9, "completion_tokens": 12, "total_tokens": 21},
-    }
-
-
-@app.post("/v1/chat/completions")
-async def chat_completions(request: Request):
-    body = await request.json()
-    user_prompt = body["messages"][-1]["content"]
-    question_number = int(user_prompt.split("XX")[1])
-
-    response = await generate_response(question_number)
-    return JSONResponse(content=response)
-
-
-def run_server():
-    uvicorn.run(app, host="127.0.0.1", port=8000)
-
-
-if __name__ == "__main__":
-    # Start the server in a separate thread
-    server_thread = threading.Thread(target=run_server)
-    server_thread.start()
-
-# Your main code here
-# ...
-
-# To use this with the OpenAI SDK:
-# from openai import AsyncOpenAI
-# client = AsyncOpenAI(base_url="http://127.0.0.1:8000/v1", api_key="fake_key")
-# response = await client.chat.completions.create(model="gpt-3.5-turbo", messages=[...])
+import threading
+import asyncio
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+import uvicorn
+import json
+from typing import Any
+
+app = FastAPI()
+
+
+async def generate_response(question_number: int) -> dict:
+    # Simulate some asynchronous work
+    await asyncio.sleep(1)
+    return {
+        "id": "chatcmpl-123",
+        "object": "chat.completion",
+        "created": 1677652288,
+        "model": "gpt-3.5-turbo-0613",
+        "choices": [
+            {
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": json.dumps(
+                        {"answer": f"SPAM for question {question_number}!"}
+                    ),
+                },
+                "finish_reason": "stop",
+            }
+        ],
+        "usage": {"prompt_tokens": 9, "completion_tokens": 12, "total_tokens": 21},
+    }
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: Request):
+    body = await request.json()
+    user_prompt = body["messages"][-1]["content"]
+    question_number = int(user_prompt.split("XX")[1])
+
+    response = await generate_response(question_number)
+    return JSONResponse(content=response)
+
+
+def run_server():
+    uvicorn.run(app, host="127.0.0.1", port=8000)
+
+
+if __name__ == "__main__":
+    # Start the server in a separate thread
+    server_thread = threading.Thread(target=run_server)
+    server_thread.start()
+
+# Your main code here
+# ...
+
+# To use this with the OpenAI SDK:
+# from openai import AsyncOpenAI
+# client = AsyncOpenAI(base_url="http://127.0.0.1:8000/v1", api_key="fake_key")
+# response = await client.chat.completions.create(model="gpt-3.5-turbo", messages=[...])

edsl/language_models/registry.py

@@ -1,137 +1,137 @@
-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")
-
-
-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 [m[0] for m in full_list]
-            else:
-                return full_list
-        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 [m[0] for m in filtered_results]
-            else:
-                return filtered_results
-
-    @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)
+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")
+
+
+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 [m[0] for m in full_list]
+            else:
+                return full_list
+        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 [m[0] for m in filtered_results]
+            else:
+                return filtered_results
+
+    @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)