fix: make AsyncOgxClient functional by inheriting from sync ApiClient (#6372)

# What does this PR do?

The AsyncOgxClient was completely non-functional. Any API call through
it would immediately crash with AttributeError: 'AsyncApiClient' object
has no attribute 'select_header_accept' because AsyncApiClient was a
standalone class missing 15+ methods (select_header_accept,
param_serialize, call_api, response_deserialize, etc.) that the
generated API classes depend on. Additionally, all API methods wired
into AsyncOgxClient were synchronous and could not be awaited, and
nested API wiring (e.g. client.chat.completions) was never applied.

This PR fixes the async client by:
- Making AsyncApiClient inherit from ApiClient, overriding only the HTTP
transport layer (__init__, call_api, close, context managers). All
serialization/deserialization methods are inherited unchanged.
- Generating proper Async*Api subclasses (e.g.
AsyncInspectApi(InspectApi)) in the same file via the api.mustache
template. These inherit _serialize helpers and override the operation
methods with async def / await.
- Updating AsyncOgxClient to wire Async*Api classes instead of sync
ones.
- Fixing patch_hierarchy.py to apply nested API wiring to both OgxClient
and AsyncOgxClient.
- Adding RESTResponse.aread() for async response body reading.
- Updating export templates (exports_api.mustache,
exports_package.mustache, __init__package.mustache) to include the new
Async*Api classes.

## Test Plan

Ran integration test to validate no regression for sync client
Ran this simple script to validate async is at least somewhat working;
```python
import asyncio
from ogx_client import AsyncOgxClient


async def main():
    async with AsyncOgxClient(base_url="http://localhost:8321") as client:
        health = await client.inspect.health()
        models = await client.models.list()
        print(f"Health {health}")
        print(f"Models {models}")


asyncio.run(main())
```

---------

Signed-off-by: Eitan Geiger <egeiger@redhat.com>
Co-authored-by: Charlie Doern <cdoern@redhat.com>

Author: aegeiger

client-sdks/openapi/patch_hierarchy.py

@@ -152,11 +152,13 @@ def patch_optional_import(api_file: Path) -> bool:
 
 
 def patch_ogx_client(client_file: Path, pairs: list[tuple[str, str]]) -> bool:
-    """Patch OgxClient to wire up parent-child API relationships.
+    """Patch OgxClient and AsyncOgxClient to wire up parent-child API relationships.
 
-    Looks for the '# Nested API structure' comment and inserts assignments like:
+    Looks for all '# Nested API structure' comment anchors and inserts assignments like:
         self.chat.completions = self.completions
 
+    This handles both OgxClient and AsyncOgxClient in the same file.
+
     Returns True if the file was modified.
     """
     if not client_file.exists():
@@ -166,14 +168,13 @@ def patch_ogx_client(client_file: Path, pairs: list[tuple[str, str]]) -> bool:
     with open(client_file) as f:
         lines = f.readlines()
 
-    # Find the anchor comment
-    comment_idx = None
+    # Find all anchor comment indices
+    comment_indices = []
     for i, line in enumerate(lines):
         if "# Nested API structure" in line:
-            comment_idx = i
-            break
+            comment_indices.append(i)
 
-    if comment_idx is None:
+    if not comment_indices:
         print(f"  Warning: '# Nested API structure' comment not found in {client_file}")
         return False
 
@@ -185,30 +186,32 @@ def patch_ogx_client(client_file: Path, pairs: list[tuple[str, str]]) -> bool:
         if any(test_line in line for line in lines):
             return False
 
-    comment_line = lines[comment_idx]
-    indent = len(comment_line) - len(comment_line.lstrip())
-
-    patch_lines = [f"{' ' * indent}# Wire up parent-child API relationships\n"]
-    for parent_tag, child_tag in pairs:
-        parent_snake = to_snake_case(parent_tag)
-        child_snake = to_snake_case(child_tag)
-        patch_lines.append(f"{' ' * indent}self.{parent_snake}.{child_snake} = self.{child_snake}\n")
-        # Also add a short alias if the child name is prefixed with the parent name
-        # e.g., chat_completions -> chat.completions
-        if child_snake.startswith(f"{parent_snake}_"):
-            subresource_name = child_snake.removeprefix(f"{parent_snake}_")
-            patch_lines.append(
-                f"{' ' * indent}self.{parent_snake}.__dict__['{subresource_name}'] = self.{child_snake}\n"
-            )
-
-    insert_idx = comment_idx + 1
-    for line in reversed(patch_lines):
-        lines.insert(insert_idx, line)
+    # Patch each anchor (process in reverse so line indices remain valid)
+    for comment_idx in reversed(comment_indices):
+        comment_line = lines[comment_idx]
+        indent = len(comment_line) - len(comment_line.lstrip())
+
+        patch_lines = [f"{' ' * indent}# Wire up parent-child API relationships\n"]
+        for parent_tag, child_tag in pairs:
+            parent_snake = to_snake_case(parent_tag)
+            child_snake = to_snake_case(child_tag)
+            patch_lines.append(f"{' ' * indent}self.{parent_snake}.{child_snake} = self.{child_snake}\n")
+            # Also add a short alias if the child name is prefixed with the parent name
+            # e.g., chat_completions -> chat.completions
+            if child_snake.startswith(f"{parent_snake}_"):
+                subresource_name = child_snake.removeprefix(f"{parent_snake}_")
+                patch_lines.append(
+                    f"{' ' * indent}self.{parent_snake}.__dict__['{subresource_name}'] = self.{child_snake}\n"
+                )
+
+        insert_idx = comment_idx + 1
+        for line in reversed(patch_lines):
+            lines.insert(insert_idx, line)
 
     with open(client_file, "w") as f:
         f.writelines(lines)
 
-    print(f"  Patched OgxClient with {len(pairs)} parent-child relationships")
+    print(f"  Patched OgxClient and AsyncOgxClient with {len(pairs)} parent-child relationships each")
     return True
 
 

client-sdks/openapi/templates/python/__init__package.mustache

@@ -29,6 +29,7 @@ __all__ = [
     "OgxClient",
     "AsyncOgxClient",
     {{#apiInfo}}{{#apis}}"{{classname}}",
+    "Async{{classname}}",
     {{/apis}}{{/apiInfo}}"ApiResponse",
     "APIResponse",
     "ApiClient",

client-sdks/openapi/templates/python/api.mustache

@@ -18,9 +18,11 @@ from typing_extensions import Annotated
 {{/imports}}
 
 from {{packageName}}.api_client import ApiClient, RequestSerialized
+from {{packageName}}.async_api_client import AsyncApiClient
 from {{packageName}}.api_response import ApiResponse
 from {{packageName}}.rest import RESTResponseType
 from {{packageName}}.stream import Stream
+from {{packageName}}.async_stream import AsyncStream
 from {{packageName}}.lib._utils import pascal_to_snake_case
 
 
@@ -339,5 +341,148 @@ class {{classname}}:
     {{alias}} = {{target}}
 {{/vendorExtensions.x-operation-aliases}}
 
+{{/operation}}
+
+
+class Async{{classname}}({{classname}}):
+    """Async version of {{classname}}.
+
+    Inherits serialization and deserialization from {{classname}}.
+    Overrides HTTP methods to use async/await with AsyncApiClient.
+    """
+
+    def __init__(self, api_client=None) -> None:
+        if api_client is None:
+            api_client = AsyncApiClient.get_default()
+        self.api_client = api_client
+        self.logger = logging.getLogger(Async{{classname}}.__name__)
+
+        # Child API attributes (set by AsyncOgxClient based on x-nesting-path)
+{{#operation}}{{#vendorExtensions.x-nesting-path}}{{#-first}}{{#tags}}{{#-first}}{{#vendorExtensions.x-nesting-path}}{{^-last}}        self.{{.}}: Any | None = None  # Next in nesting path
+{{/-last}}{{/vendorExtensions.x-nesting-path}}{{/-first}}{{/tags}}{{/-first}}{{/vendorExtensions.x-nesting-path}}{{/operation}}
+
+    def _create_event_stream(self, response_data: RESTResponseType, stream_type_name: str) -> AsyncStream[Any]:
+        """Create a typed async event stream from an SSE response.
+
+        Args:
+            response_data: The raw HTTP response containing the SSE stream.
+            stream_type_name: The schema name for the streaming response type.
+        """
+        stream_class = None
+        discriminator_map = None
+        discriminator_property = None
+        try:
+            module_name = pascal_to_snake_case(stream_type_name)
+            model_module = importlib.import_module('{{packageName}}.models.' + module_name)
+            stream_class = getattr(model_module, stream_type_name)
+            discriminator_map = getattr(stream_class, 'discriminator_value_class_map', None)
+            discriminator_property = getattr(stream_class, 'discriminator_property_name', None)
+        except (ImportError, ModuleNotFoundError, AttributeError) as e:
+            self.logger.debug(f"Could not import stream type {stream_type_name}: {e}")
+
+        def stream_decoder(data_str: str) -> Any:
+            if not data_str:
+                return None
+            try:
+                data = json.loads(data_str)
+            except json.JSONDecodeError:
+                return data_str
+
+            if discriminator_map and discriminator_property:
+                disc_value = data.get(discriminator_property, '')
+                variant_class_name = discriminator_map.get(disc_value)
+                if variant_class_name:
+                    try:
+                        variant_module_name = pascal_to_snake_case(variant_class_name)
+                        variant_module = importlib.import_module('{{packageName}}.models.' + variant_module_name)
+                        variant_class = getattr(variant_module, variant_class_name)
+                        return variant_class.from_dict(data)
+                    except Exception as e:
+                        self.logger.debug(f"Failed to deserialize as {variant_class_name}: {e}")
+
+            if stream_class is not None:
+                try:
+                    result = stream_class.from_dict(data)
+                    if hasattr(result, 'actual_instance') and result.actual_instance is not None:
+                        return result.actual_instance
+                    return result
+                except Exception as e:
+                    self.logger.debug(f"Failed to deserialize as {stream_type_name}: {e}")
+
+            return data
+
+        return AsyncStream(
+            response=response_data.response,
+            client=self.api_client,
+            decoder=stream_decoder,
+        )
+
+{{#operation}}
+
+    @validate_call
+    async def {{#vendorExtensions.x-operation-name}}{{vendorExtensions.x-operation-name}}{{/vendorExtensions.x-operation-name}}{{^vendorExtensions.x-operation-name}}{{operationId}}{{/vendorExtensions.x-operation-name}}{{>partial_api_args}} -> {{#vendorExtensions.x-streaming}}{{#vendorExtensions.x-unwrap-list-response}}{{#returnType}}{{#returnContainer}}{{{returnBaseType}}} | AsyncStream[{{{returnBaseType}}}]{{/returnContainer}}{{^returnContainer}}{{{returnType}}} | AsyncStream[{{{returnType}}}]{{/returnContainer}}{{/returnType}}{{^returnType}}None | AsyncStream[None]{{/returnType}}{{/vendorExtensions.x-unwrap-list-response}}{{^vendorExtensions.x-unwrap-list-response}}{{{returnType}}}{{^returnType}}None{{/returnType}} | AsyncStream[{{{returnType}}}{{^returnType}}None{{/returnType}}]{{/vendorExtensions.x-unwrap-list-response}}{{/vendorExtensions.x-streaming}}{{^vendorExtensions.x-streaming}}{{#vendorExtensions.x-unwrap-list-response}}{{#returnType}}{{#returnContainer}}{{{returnBaseType}}}{{/returnContainer}}{{^returnContainer}}{{{returnType}}}{{/returnContainer}}{{/returnType}}{{^returnType}}None{{/returnType}}{{/vendorExtensions.x-unwrap-list-response}}{{^vendorExtensions.x-unwrap-list-response}}{{{returnType}}}{{^returnType}}None{{/returnType}}{{/vendorExtensions.x-unwrap-list-response}}{{/vendorExtensions.x-streaming}}:
+{{>partial_api}}
+
+        response_data = await self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+{{#vendorExtensions.x-streaming}}
+        # Check if this is a streaming response
+        content_type = response_data.response.headers.get('Content-Type', '')
+        if 'text/event-stream' in content_type:
+            return self._create_event_stream(response_data, "{{vendorExtensions.x-streaming-type}}")
+
+{{/vendorExtensions.x-streaming}}
+        await response_data.aread()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        {{#vendorExtensions.x-unwrap-list-response}}
+        if _deserialized is not None and hasattr(_deserialized, 'data'):
+            return _deserialized.data
+        {{/vendorExtensions.x-unwrap-list-response}}
+        return _deserialized
+
+    @validate_call
+    async def {{#vendorExtensions.x-operation-name}}{{vendorExtensions.x-operation-name}}{{/vendorExtensions.x-operation-name}}{{^vendorExtensions.x-operation-name}}{{operationId}}{{/vendorExtensions.x-operation-name}}_with_http_info{{>partial_api_args}} -> {{#vendorExtensions.x-streaming}}ApiResponse[{{{returnType}}}{{^returnType}}None{{/returnType}}] | AsyncStream[{{{returnType}}}{{^returnType}}None{{/returnType}}]{{/vendorExtensions.x-streaming}}{{^vendorExtensions.x-streaming}}ApiResponse[{{{returnType}}}{{^returnType}}None{{/returnType}}]{{/vendorExtensions.x-streaming}}:
+{{>partial_api}}
+
+        response_data = await self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+{{#vendorExtensions.x-streaming}}
+        # Check if this is a streaming response
+        content_type = response_data.response.headers.get('Content-Type', '')
+        if 'text/event-stream' in content_type:
+            return self._create_event_stream(response_data, "{{vendorExtensions.x-streaming-type}}")
+
+{{/vendorExtensions.x-streaming}}
+        await response_data.aread()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    async def {{#vendorExtensions.x-operation-name}}{{vendorExtensions.x-operation-name}}{{/vendorExtensions.x-operation-name}}{{^vendorExtensions.x-operation-name}}{{operationId}}{{/vendorExtensions.x-operation-name}}_without_preload_content{{>partial_api_args}} -> RESTResponseType:
+{{>partial_api}}
+
+        response_data = await self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+{{#vendorExtensions.x-operation-aliases}}
+    {{alias}} = {{target}}
+{{/vendorExtensions.x-operation-aliases}}
+
 {{/operation}}
 {{/operations}}