Fix handling union types inside typing.Optional

Author: yugokato

src/openapi_test_client/libraries/api/api_functions/utils/param_model.py

@@ -34,17 +34,17 @@
 logger = get_logger(__name__)
 
 
-def is_param_model(annotated_type: Any) -> bool:
-    """Check if the given annotated type is for a custom model
+def has_param_model(annotated_type: Any) -> bool:
+    """Check if the given annotated type contains a custom param model
 
-    :param annotated_type: Annotated type for a field to check whether it is a param model or not
+    :param annotated_type: Annotated type for a field to check whether it contains a param model or not
     """
 
     def _is_param_model(obj: Any) -> bool:
-        return inspect.isclass(obj) and (issubclass(obj, ParamModel))
+        return inspect.isclass(obj) and issubclass(obj, ParamModel)
 
     inner_type = param_type_util.get_inner_type(annotated_type)
-    if get_origin(inner_type) in [Union, UnionType]:
+    if param_type_util.is_union_type(inner_type):
         return any(_is_param_model(o) for o in get_args(inner_type))
     else:
         return _is_param_model(inner_type)
@@ -56,9 +56,9 @@ def get_param_model(annotated_type: Any) -> ParamModel | list[ParamModel] | None
     :param annotated_type: Annotated type
     """
     inner_type = param_type_util.get_inner_type(annotated_type)
-    if is_param_model(inner_type):
-        if get_origin(inner_type) in [Union, UnionType]:
-            return list(get_args(inner_type))
+    if has_param_model(inner_type):
+        if param_type_util.is_union_type(inner_type):
+            return [x for x in get_args(inner_type) if has_param_model(x)]
         else:
             return inner_type
 
@@ -160,7 +160,7 @@ def generate_imports_code(obj_type: Any):
                     [generate_imports_code(m) for m in get_args(obj_type)]
                 else:
                     raise NotImplementedError(f"Unsupported typing origin: {typing_origin}")
-            elif is_param_model(obj_type):
+            elif has_param_model(obj_type):
                 if not exclude_nested_models:
                     api_cls_module, model_file_name = api_class.__module__.rsplit(".", 1)
                     module_and_name_pairs.append(
@@ -226,7 +226,7 @@ def get_param_models(model: type[EndpointModel | ParamModel], recursive: bool =
 
     def collect_param_models(model: type[EndpointModel | ParamModel]):
         for field_name, field_obj in model.__dataclass_fields__.items():
-            if is_param_model(field_obj.type):
+            if has_param_model(field_obj.type):
                 model_name = generate_model_name(field_name, field_obj.type)
                 param_def = ParamDef.from_param_obj(field_obj.metadata)
                 param_model = create_model_from_param_def(model_name, param_def)

src/openapi_test_client/libraries/api/api_functions/utils/param_type.py

@@ -159,9 +159,9 @@ def resolve(param_type: str, param_format: str | None = None):
             # code will be valid. So ignoring the warning here.
             type_annotation = Literal[*enum]  # type: ignore
         elif isinstance(param_def, ParamDef.UnknownType):
-            logger.exception(
+            logger.warning(
                 f"Unable to locate a parameter type for parameter '{param_name}'. Type '{Any}' will be applied.\n"
-                f"Failed parameter object:\n{param_def.param_obj}"
+                f"Failed parameter object: {param_def.param_obj}"
             )
             type_annotation = Any
         else:
@@ -193,42 +193,37 @@ def resolve(param_type: str, param_format: str | None = None):
     return type_annotation
 
 
-def get_inner_type(tp: Any, return_if_container_type: bool = False) -> Any | tuple[Any] | list[Any]:
+def get_inner_type(tp: Any, return_if_container_type: bool = False) -> Any | list[Any]:
     """Get the inner type (=actual type) from the type annotation
 
     eg:
         Optional[str] -> str
+        Optional[str | int] -> str | int
         Annotated[str, "metadata"] -> str
         Literal[1,2,3] -> Literal[1,2,3]
         list[str] -> str (list[str] if return_if_container_type=True)
-        str | int -> (str, int)
+        str | int -> str | int
 
         NOTE: This should also work with the combination of above
 
     :param tp: Type annotation
     :param return_if_container_type: Consider container type like list and tuple as the inner type
     """
     if origin_type := get_origin(tp):
-        args = get_args(tp)
+        if origin_type not in [Optional, Union, UnionType, Annotated, Literal, list, dict]:
+            raise RuntimeError(f"Found unexpected origin type in '{tp}': {origin_type}")
+
         if is_union_type(tp):
-            if is_optional_type(tp):
-                return get_inner_type(args[0])
-            else:
-                return args
+            args_without_nonetype = [x for x in get_args(tp) if x is not NoneType]
+            return generate_union_type([get_inner_type(x) for x in args_without_nonetype])
         elif origin_type is Annotated:
             return get_inner_type(tp.__origin__)
-        elif origin_type in [list, tuple]:
+        elif origin_type is list:
             if return_if_container_type:
                 return tp
             else:
-                if origin_type is list:
-                    return get_inner_type(args[0])
-                else:
-                    return get_inner_type(args)
-        else:
-            return tp
-    else:
-        return tp
+                return get_inner_type(get_args(tp)[0])
+    return tp
 
 
 def replace_inner_type(tp: Any, new_type: Any, replace_container_type: bool = False) -> Any: