Python housekeeping (#188)

* Remove `DefaultOpenAIModel` from API.

* Format `model.py`.

* Include `spotipy` as what's effectively a devDependency for our examples.

* Update version to `0.0.2` so we can publish.

* Add explicit support for Python 3.12 in the `classifiers` list.

* Fixed type errors in the `math` example.

* Updates to `agents`, and `math` example to avoid weird `Unknown` issues.

* fixup: remove unused import

* Add type: ignore for `spotipy` import.

* Remove type-checking errors.

* Ensure that 'exit' and 'quit' work in process_requests.

* Fix up math example, remove redundancy, document issues around JsonProgram in the math example.

* Make the program validators/translators non-generic.

Author: DanielRosenwasser

python/examples/math/demo.py

@@ -1,19 +1,28 @@
 import asyncio
+from collections.abc import Sequence
 import json
 import sys
+from typing import cast
 from dotenv import dotenv_values
 import schema as math
 from typechat import Failure, create_language_model, process_requests
-from program import TypeChatProgramTranslator, TypeChatProgramValidator, JsonProgram, evaluate_json_program  # type: ignore
+from program import TypeChatProgramTranslator, TypeChatProgramValidator, evaluate_json_program
 
 vals = dotenv_values()
 model = create_language_model(vals)
-validator = TypeChatProgramValidator(JsonProgram)
+validator = TypeChatProgramValidator()
 translator = TypeChatProgramTranslator(model, validator, math.MathAPI)
 
 
-async def apply_operations(func: str, args: list[int | float]) -> int | float:
+async def apply_operations(func: str, args: Sequence[object]) -> int | float:
     print(f"{func}({json.dumps(args)}) ")
+
+    for arg in args:
+        if not isinstance(arg, (int, float)):
+            raise ValueError("All arguments are expected to be numeric.")
+
+    args = cast(Sequence[int | float], args)
+
     match func:
         case "add":
             return args[0] + args[1]
@@ -38,7 +47,7 @@ async def request_handler(message: str):
     else:
         result = result.value
         print(json.dumps(result, indent=2))
-        math_result = await evaluate_json_program(result, apply_operations)  # type: ignore
+        math_result = await evaluate_json_program(result, apply_operations)
         print(f"Math Result: {math_result}")
 
 

python/examples/math/program.py

@@ -1,17 +1,16 @@
 from __future__ import annotations
 import asyncio
+from collections.abc import Sequence
 import json
-from typing import TypedDict, no_type_check
+from typing import Any, TypeAlias, TypedDict, cast
 from typing_extensions import (
     TypeVar,
     Callable,
     Awaitable,
     Annotated,
     NotRequired,
     override,
-    Sequence,
     Doc,
-    Any,
 )
 
 from typechat import (
@@ -23,7 +22,6 @@
     TypeChatTranslator,
     python_type_to_typescript_schema,
 )
-import collections.abc
 
 T = TypeVar("T", covariant=True)
 
@@ -70,75 +68,90 @@
     },
 )
 
-JsonValue = str | int | float | bool | None | dict[str, "Expression"] | list["Expression"]
-Expression = JsonValue | FunctionCall | ResultReference # type: ignore
+JsonValue: TypeAlias = str | int | float | bool | None | dict[str, "Expression"] | list["Expression"]
+Expression: TypeAlias = JsonValue | FunctionCall | ResultReference
 
 JsonProgram = TypedDict("JsonProgram", {"@steps": list[FunctionCall]})
 
-@no_type_check
 async def evaluate_json_program(
-    program: JsonProgram, onCall: Callable[[str, Sequence[Expression]], Awaitable[Expression]]
-) -> Expression | Sequence[Expression]:
-    results: list[Expression] | Expression = []
-
-    @no_type_check
-    async def evaluate_array(array: Sequence[Expression]) -> Sequence[Expression]:
-        return await asyncio.gather(*[evaluate_call(e) for e in array])
-
-    @no_type_check
-    async def evaluate_object(expr: FunctionCall):
-        if "@ref" in expr:
-            index = expr["@ref"]
-            if index < len(results):
-                return results[index]
-
-        elif "@func" in expr and "@args" in expr:
-            function_name = expr["@func"]
-            return await onCall(function_name, await evaluate_array(expr["@args"]))
-
-        elif isinstance(expr, collections.abc.Sequence):
-            return await evaluate_array(expr)
-
-        else:
-            raise ValueError("This condition should never hit")
-
-    @no_type_check
-    async def evaluate_call(expr: FunctionCall) -> Expression | Sequence[Expression]:
-        if isinstance(expr, int) or isinstance(expr, float) or isinstance(expr, str):
-            return expr
-        return await evaluate_object(expr)
+    program: JsonProgram,
+    onCall: Callable[[str, Sequence[object]], Awaitable[JsonValue]]
+) -> Expression:
+    results: list[JsonValue] = []
+
+    def evaluate_array(array: Sequence[Expression]) -> Awaitable[list[Expression]]:
+        return asyncio.gather(*[evaluate_expression(e) for e in array])
+
+    async def evaluate_expression(expr: Expression) -> JsonValue:
+        match expr:
+            case bool() | int() | float() | str() | None:
+                return expr
+
+            case { "@ref": int(index) } if not isinstance(index, bool):
+                if 0 <= index < len(results):
+                    return results[index]
+                
+                raise ValueError(f"Index {index} is out of range [0, {len(results)})")
+
+            case { "@ref": ref_value }:
+                raise ValueError(f"'ref' value must be an integer, but was ${ref_value}")
+
+            case { "@func": str(function_name) }:
+                args: list[Expression]
+                match expr:
+                    case { "@args": None }:
+                        args = []
+                    case { "@args": list() }:
+                        args = cast(list[Expression], expr["@args"]) # TODO
+                    case { "@args": _ }:
+                        raise ValueError("Given an invalid value for '@args'.")
+                    case _:
+                        args = []
+
+                return await onCall(function_name, await evaluate_array(args))
+            
+            case list(array_expression_elements):
+                return await evaluate_array(array_expression_elements)    
+
+            case _:
+                raise ValueError("This condition should never hit")
 
     for step in program["@steps"]:
-        results.append(await evaluate_call(step))
+        results.append(await evaluate_expression(step))
 
     if len(results) > 0:
         return results[-1]
     else:
         return None
 
 
-class TypeChatProgramValidator(TypeChatValidator[T]):
-    def __init__(self, py_type: type[T]):
-        # the base class init method creates a typeAdapter for T. This operation fails for the JsonProgram type
-        super().__init__(py_type=Any)  # type: ignore
+class TypeChatProgramValidator(TypeChatValidator[JsonProgram]):
+    def __init__(self):
+        # TODO: This example should eventually be updated to use Python 3.12 type aliases
+        # Passing in `JsonProgram` for `py_type` would cause issues because
+        # Pydantic's `TypeAdapter` ends up trying to eagerly construct an
+        # anonymous recursive type. Even a NewType does not work here.
+        # For now, we just pass in `Any` in place of `JsonProgram`.
+        super().__init__(py_type=cast(type[JsonProgram], Any))
 
     @override
-    def validate(self, json_text: str) -> Result[T]:
+    def validate(self, json_text: str) -> Result[JsonProgram]:
         # Pydantic is not able to validate JsonProgram instances. It fails with a recursion error.
-        # For JsonProgram, simply validate that it has a non-zero number of @steps
+        # For JsonProgram, so we simply validate that it has a non-zero number of `@steps`.
         # TODO: extend validations
         typed_dict = json.loads(json_text)
-        if "@steps" in typed_dict and isinstance(typed_dict["@steps"], collections.abc.Sequence):
+        if "@steps" in typed_dict and isinstance(typed_dict["@steps"], Sequence):
             return Success(typed_dict)
         else:
             return Failure("This is not a valid program. The program must have an array of @steps")
 
 
-class TypeChatProgramTranslator(TypeChatTranslator[T]):
+class TypeChatProgramTranslator(TypeChatTranslator[JsonProgram]):
     _api_declaration_str: str
 
-    def __init__(self, model: TypeChatModel, validator: TypeChatProgramValidator[T], api_type: type):
+    def __init__(self, model: TypeChatModel, validator: TypeChatProgramValidator, api_type: type):
         super().__init__(model=model, validator=validator, target_type=api_type)
+        # TODO: the conversion result here has errors!
         conversion_result = python_type_to_typescript_schema(api_type)
         self._api_declaration_str = conversion_result.typescript_schema_str
 

python/examples/multiSchema/agents.py

@@ -1,5 +1,7 @@
+from collections.abc import Sequence
 import os
 import sys
+from typing import cast
 
 examples_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
 if examples_path not in sys.path:
@@ -14,8 +16,7 @@
 from examples.math.program import (
     TypeChatProgramTranslator,
     TypeChatProgramValidator,
-    evaluate_json_program,  # type: ignore
-    JsonProgram,
+    evaluate_json_program,
 )
 
 import examples.music.schema as music_schema
@@ -43,16 +44,23 @@ async def handle_request(self, line: str):
 
 
 class MathAgent:
-    _validator: TypeChatProgramValidator[JsonProgram]
-    _translator: TypeChatProgramTranslator[JsonProgram]
+    _validator: TypeChatProgramValidator
+    _translator: TypeChatProgramTranslator
 
     def __init__(self, model: TypeChatModel):
         super().__init__()
-        self._validator = TypeChatProgramValidator(JsonProgram)
+        self._validator = TypeChatProgramValidator()
         self._translator = TypeChatProgramTranslator(model, self._validator, math_schema.MathAPI)
 
-    async def _handle_json_program_call(self, func: str, args: list[int | float]) -> int | float:
+    async def _handle_json_program_call(self, func: str, args: Sequence[object]) -> int | float:
         print(f"{func}({json.dumps(args)}) ")
+        
+        for arg in args:
+            if not isinstance(arg, (int, float)):
+                raise ValueError("All arguments are expected to be numeric.")
+
+        args = cast(Sequence[int | float], args)
+
         match func:
             case "add":
                 return args[0] + args[1]

python/notebooks/math.ipynb

@@ -34,7 +34,7 @@
    "source": [
     "from dotenv import dotenv_values\n",
     "from typechat import Failure, create_language_model\n",
-    "from examples.math.program import TypeChatProgramTranslator, TypeChatProgramValidator, JsonProgram, evaluate_json_program\n",
+    "from examples.math.program import TypeChatProgramTranslator, TypeChatProgramValidator, evaluate_json_program\n",
     "from examples.math import schema as math"
    ]
   },
@@ -46,7 +46,7 @@
    "source": [
     "vals = dotenv_values()\n",
     "model = create_language_model(vals)\n",
-    "validator = TypeChatProgramValidator(JsonProgram)\n",
+    "validator = TypeChatProgramValidator()\n",
     "translator = TypeChatProgramTranslator(model, validator, math.MathAPI)"
    ]
   },

python/pyproject.toml

@@ -17,6 +17,7 @@ classifiers = [
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
@@ -41,8 +42,10 @@ dependencies = [
   "openai>=1.3.6",
   "python-dotenv>=1.0.0",
   "pytest",
+  "spotipy", # for examples
   "typing_extensions",
 ]
+
 [tool.hatch.envs.default.scripts]
 test = "pytest {args:tests}"
 test-cov = "coverage run -m pytest {args:tests}"
@@ -55,11 +58,6 @@ cov = [
   "cov-report",
 ]
 
-[tool.hatch.envs.examples]
-extra-dependencies = [
-  "spotipy",
-]
-
 [[tool.hatch.envs.all.matrix]]
 python = ["3.11"]
 

python/src/typechat/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: Microsoft Corporation
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.0.1"
+__version__ = "0.0.2"

python/src/typechat/__init__.py

@@ -2,15 +2,14 @@
 #
 # SPDX-License-Identifier: MIT
 
-from typechat._internal.model import DefaultOpenAIModel, TypeChatModel, create_language_model
+from typechat._internal.model import TypeChatModel, create_language_model
 from typechat._internal.result import Failure, Result, Success
 from typechat._internal.translator import TypeChatTranslator
 from typechat._internal.ts_conversion import python_type_to_typescript_schema
 from typechat._internal.validator import TypeChatValidator
 from typechat._internal.interactive import process_requests
 
 __all__ = [
-    "DefaultOpenAIModel",
     "TypeChatModel",
     "TypeChatTranslator",
     "TypeChatValidator",

python/src/typechat/_internal/interactive.py

@@ -13,7 +13,7 @@ async def process_requests(interactive_prompt: str, input_file_name: str | None,
     else:
         print(interactive_prompt, end="", flush=True)
         for line in sys.stdin:
-            lower_line = line.lower()
+            lower_line = line.lower().strip()
             if lower_line == "quit" or lower_line == "exit":
                 break
             else:

python/src/typechat/_internal/model.py

@@ -35,19 +35,23 @@ async def complete(self, input: str) -> Result[str]:
             return Failure(str(e))
 
 def create_language_model(vals: dict[str,str|None]) -> TypeChatModel:
-    model:TypeChatModel
+    model: TypeChatModel
     client: openai.AsyncOpenAI | openai.AsyncAzureOpenAI
-    
+
     if "OPENAI_API_KEY" in vals:
         client = openai.AsyncOpenAI(api_key=vals["OPENAI_API_KEY"])
         model = DefaultOpenAIModel(model_name=vals.get("OPENAI_MODEL", None) or "gpt-35-turbo", client=client)
 
     elif "AZURE_OPENAI_API_KEY" in vals and "AZURE_OPENAI_ENDPOINT" in vals:
         os.environ["OPENAI_API_TYPE"] = "azure"
-        client=openai.AsyncAzureOpenAI(azure_endpoint=vals.get("AZURE_OPENAI_ENDPOINT",None) or "", api_key=vals["AZURE_OPENAI_API_KEY"],api_version="2023-03-15-preview")
+        client = openai.AsyncAzureOpenAI(
+            azure_endpoint=vals.get("AZURE_OPENAI_ENDPOINT", None) or "",
+            api_key=vals["AZURE_OPENAI_API_KEY"],
+            api_version="2023-03-15-preview",
+        )
         model = DefaultOpenAIModel(model_name=vals.get("AZURE_OPENAI_MODEL", None) or "gpt-35-turbo", client=client)
-    
+
     else:
         raise ValueError("Missing environment variables for Open AI or Azure OpenAI model")
-        
-    return model
+
+    return model