Adapt to eager openai.types loading via _client

The 2.32.0 release added 'from .types.websocket_reconnection import ...'
at the top of openai/__init__.py, which transitively loads openai.types
through openai._client as well. That invalidates the 'openai.types is
lazy' assertion the earlier test relied on, so the lazy-types live test
is removed and the remaining tests assert the boundaries that still
hold (lib.azure, lib.streaming, lib._tools).

Also stabilize pyright under strict:
 - preserve static visibility of AzureOpenAI / AsyncAzureOpenAI /
   pydantic_function_tool / AssistantEventHandler under TYPE_CHECKING
   so callers keep their signatures
 - rename _AZURE_MODULE_CLIENT_CLASS to a non-constant symbol and type
   the module-client factory as type[AzureOpenAI] to silence strict
   reportCallIssue / reportConstantRedefinition warnings
 - tidy ruff imports / I001 noise in scripts/bench_import.py and the
   test files added in this branch

Author: fede-kamel

scripts/bench_import.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 from __future__ import annotations
 
-import argparse
 import os
-import subprocess
 import sys
 import time
+import argparse
+import subprocess
 from pathlib import Path
 
 

src/openai/__init__.py

@@ -97,7 +97,16 @@
 
 if _t.TYPE_CHECKING:
     from . import types as types
-    from .lib.azure import AzureADTokenProvider, AzureOpenAI, AsyncAzureOpenAI
+    from .lib.azure import (
+        AzureOpenAI as AzureOpenAI,
+        AsyncAzureOpenAI as AsyncAzureOpenAI,
+        AzureADTokenProvider,
+    )
+    from .lib._tools import pydantic_function_tool as pydantic_function_tool
+    from .lib.streaming import (
+        AssistantEventHandler as AssistantEventHandler,
+        AsyncAssistantEventHandler as AsyncAssistantEventHandler,
+    )
 
 from .version import VERSION as VERSION
 from .lib._old_api import *
@@ -332,25 +341,25 @@ def _client(self, value: _httpx.Client) -> None:  # type: ignore
         http_client = value
 
 
-def _create_azure_module_client_class() -> type[OpenAI]:
+def _create_azure_module_client_class() -> type[AzureOpenAI]:
     from .lib.azure import AzureOpenAI
 
     class _AzureModuleClient(_ModuleClient, AzureOpenAI):  # type: ignore
         ...
 
-    return _AzureModuleClient
+    return _AzureModuleClient  # type: ignore[return-value]
 
 
-_AZURE_MODULE_CLIENT_CLASS: type[OpenAI] | None = None
+_azure_module_client_class_cache: type[AzureOpenAI] | None = None
 
 
-def _azure_module_client_class() -> type[OpenAI]:
-    global _AZURE_MODULE_CLIENT_CLASS
+def _azure_module_client_class() -> type[AzureOpenAI]:
+    global _azure_module_client_class_cache
 
-    if _AZURE_MODULE_CLIENT_CLASS is None:
-        _AZURE_MODULE_CLIENT_CLASS = _create_azure_module_client_class()
+    if _azure_module_client_class_cache is None:
+        _azure_module_client_class_cache = _create_azure_module_client_class()
 
-    return _AZURE_MODULE_CLIENT_CLASS
+    return _azure_module_client_class_cache
 
 
 class _AmbiguousModuleClientUsageError(OpenAIError):

src/openai/lib/__init__.py

@@ -3,8 +3,8 @@
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from ._parsing import ResponseFormatT as ResponseFormatT
     from ._tools import pydantic_function_tool as pydantic_function_tool
+    from ._parsing import ResponseFormatT as ResponseFormatT
 
 
 def __getattr__(name: str) -> Any:

tests/lib/test_import_surface_live.py

@@ -3,28 +3,34 @@
 import os
 import sys
 import importlib
+from types import ModuleType
 
 import pytest
 
 
-def _openai_modules() -> dict[str, object]:
+def _openai_modules() -> dict[str, ModuleType]:
     return {name: mod for name, mod in sys.modules.items() if name == "openai" or name.startswith("openai.")}
 
 
-def _restore_openai_modules(original_modules: dict[str, object]) -> None:
+def _restore_openai_modules(original_modules: dict[str, ModuleType]) -> None:
     for name in list(sys.modules):
         if name == "openai" or name.startswith("openai."):
             sys.modules.pop(name, None)
     sys.modules.update(original_modules)
 
 
+_LAZY_EXPORT_NAMES = (
+    "AzureOpenAI",
+    "AsyncAzureOpenAI",
+    "pydantic_function_tool",
+    "AssistantEventHandler",
+    "AsyncAssistantEventHandler",
+)
+
+
 def _resolve_lazy_exports(openai_module: object) -> None:
-    getattr(openai_module, "types")
-    getattr(openai_module, "AzureOpenAI")
-    getattr(openai_module, "AsyncAzureOpenAI")
-    getattr(openai_module, "pydantic_function_tool")
-    getattr(openai_module, "AssistantEventHandler")
-    getattr(openai_module, "AsyncAssistantEventHandler")
+    for name in _LAZY_EXPORT_NAMES:
+        getattr(openai_module, name)
 
 
 @pytest.mark.skipif(os.environ.get("OPENAI_LIVE") != "1", reason="requires OPENAI_LIVE=1")
@@ -41,7 +47,6 @@ def test_explicit_lazy_export_resolution_allows_real_request() -> None:
 
         _resolve_lazy_exports(openai)
 
-        assert "openai.types" in sys.modules
         assert "openai.lib.azure" in sys.modules
         assert "AzureOpenAI" in openai.__dict__
 

tests/test_import_surface.py

@@ -1,27 +1,39 @@
 from __future__ import annotations
 
-import importlib
 import sys
+import importlib
+from types import ModuleType
 
 
-def _openai_modules() -> dict[str, object]:
+def _openai_modules() -> dict[str, ModuleType]:
     return {name: mod for name, mod in sys.modules.items() if name == "openai" or name.startswith("openai.")}
 
 
-def _restore_openai_modules(original_modules: dict[str, object]) -> None:
+def _restore_openai_modules(original_modules: dict[str, ModuleType]) -> None:
     for name in list(sys.modules):
         if name == "openai" or name.startswith("openai."):
             sys.modules.pop(name, None)
     sys.modules.update(original_modules)
 
 
+_LAZY_EXPORT_NAMES = (
+    "AzureOpenAI",
+    "AsyncAzureOpenAI",
+    "pydantic_function_tool",
+    "AssistantEventHandler",
+    "AsyncAssistantEventHandler",
+)
+
+_LAZY_EXPORT_MODULES = (
+    "openai.lib.azure",
+    "openai.lib.streaming",
+    "openai.lib._tools",
+)
+
+
 def _resolve_lazy_exports(openai_module: object) -> None:
-    getattr(openai_module, "types")
-    getattr(openai_module, "AzureOpenAI")
-    getattr(openai_module, "AsyncAzureOpenAI")
-    getattr(openai_module, "pydantic_function_tool")
-    getattr(openai_module, "AssistantEventHandler")
-    getattr(openai_module, "AsyncAssistantEventHandler")
+    for name in _LAZY_EXPORT_NAMES:
+        getattr(openai_module, name)
 
 
 def test_openai_azure_is_lazy_imported() -> None:
@@ -50,17 +62,14 @@ def test_openai_can_explicitly_resolve_lazy_exports() -> None:
     try:
         openai = importlib.import_module("openai")
 
-        assert "openai.types" not in sys.modules
-        assert "openai.lib.azure" not in sys.modules
+        for mod_name in _LAZY_EXPORT_MODULES:
+            assert mod_name not in sys.modules
 
         _resolve_lazy_exports(openai)
 
-        assert "openai.types" in sys.modules
-        assert "openai.lib.azure" in sys.modules
-        assert "AzureOpenAI" in openai.__dict__
-        assert "AsyncAzureOpenAI" in openai.__dict__
-        assert "pydantic_function_tool" in openai.__dict__
-        assert "AssistantEventHandler" in openai.__dict__
-        assert "AsyncAssistantEventHandler" in openai.__dict__
+        for mod_name in _LAZY_EXPORT_MODULES:
+            assert mod_name in sys.modules
+        for attr_name in _LAZY_EXPORT_NAMES:
+            assert attr_name in openai.__dict__
     finally:
         _restore_openai_modules(original_modules)