Fix a few issues to address some edge cases

Author: yugokato

src/openapi_test_client/libraries/api/api_client_generator.py

@@ -363,7 +363,7 @@ def update_existing_endpoints(target_api_class: type[APIBase] = api_class) -> No
                 endpoint_spec.get("summary")
                 or endpoint_spec.get("description")
                 or "No summary or description is available for this API"
-            )
+            ).replace('"', '\\"')
             is_deprecated_api = endpoint_spec.get("deprecated", False)
             is_public_api = endpoint_spec.get("security") == []
 

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

@@ -140,66 +140,69 @@ def _parse_parameter_objects(
     https://swagger.io/specification/#parameter-object
     """
     for param_obj in deepcopy(parameter_objects):
-        param_name = param_obj["name"]
-        try:
-            param_location = param_obj["in"]
-            param_def = ParamDef.from_param_obj(param_obj)
-            # In case path parameters are incorrectly documented as required: false, we force make them required as path
-            # parameters will always be required for our client
-            is_required = True if param_location == "path" else None
-            param_type_annotation = param_type_util.resolve_type_annotation(
-                param_name, param_def, _is_required=is_required
-            )
-            if param_location in ["header", "cookies"]:
-                # We currently don't support these
-                continue
-            elif param_location == "path":
-                if param_name not in [x[0] for x in path_param_fields]:
-                    # Handle duplicates. Some API specs incorrectly document duplicated parameters
-                    path_param_fields.append(DataclassModelField(param_name, param_type_annotation))
-            elif param_location == "query":
-                if method.upper() != "GET":
-                    # Annotate query params for non GET endpoints
-                    param_type_annotation = param_type_util.annotate_type(param_type_annotation, "query")
-
-                if "schema" in param_obj:
-                    # defined as model. We unpack the model details
-                    schema_obj = param_obj["schema"]
-                    if "items" in schema_obj:
-                        schema_obj = schema_obj["items"]
-
-                    if "properties" in schema_obj:
-                        properties = schema_obj["properties"]
-
-                        for k, v in properties.items():
-                            if "name" not in properties[k]:
-                                properties[k]["name"] = k
-                            properties[k]["in"] = param_location
-
-                        # Replace the param objects and parse it again
-                        parameter_objects.clear()
-                        parameter_objects.extend(properties.values())
-                        _parse_parameter_objects(
-                            method, parameter_objects, path_param_fields, body_or_query_param_fields
-                        )
+        # NOTE: param_obj will be empty here if its $ref wasn't successfully resolved. We will ignore these
+        if param_obj:
+            param_name = ""
+            try:
+                param_name = param_obj["name"]
+                param_location = param_obj["in"]
+                param_def = ParamDef.from_param_obj(param_obj)
+                # In case path parameters are incorrectly documented as required: false, we force make them required as
+                # path parameters will always be required for our client
+                is_required = True if param_location == "path" else None
+                param_type_annotation = param_type_util.resolve_type_annotation(
+                    param_name, param_def, _is_required=is_required
+                )
+                if param_location in ["header", "cookies"]:
+                    # We currently don't support these
+                    continue
+                elif param_location == "path":
+                    if param_name not in [x[0] for x in path_param_fields]:
+                        # Handle duplicates. Some API specs incorrectly document duplicated parameters
+                        path_param_fields.append(DataclassModelField(param_name, param_type_annotation))
+                elif param_location == "query":
+                    if method.upper() != "GET":
+                        # Annotate query params for non GET endpoints
+                        param_type_annotation = param_type_util.annotate_type(param_type_annotation, "query")
+
+                    if "schema" in param_obj:
+                        # defined as model. We unpack the model details
+                        schema_obj = param_obj["schema"]
+                        if "items" in schema_obj:
+                            schema_obj = schema_obj["items"]
+
+                        if "properties" in schema_obj:
+                            properties = schema_obj["properties"]
+
+                            for k, v in properties.items():
+                                if "name" not in properties[k]:
+                                    properties[k]["name"] = k
+                                properties[k]["in"] = param_location
+
+                            # Replace the param objects and parse it again
+                            parameter_objects.clear()
+                            parameter_objects.extend(properties.values())
+                            _parse_parameter_objects(
+                                method, parameter_objects, path_param_fields, body_or_query_param_fields
+                            )
+                        else:
+                            _add_body_or_query_param_field(
+                                body_or_query_param_fields, param_name, param_type_annotation, param_obj=param_obj
+                            )
+
                     else:
                         _add_body_or_query_param_field(
                             body_or_query_param_fields, param_name, param_type_annotation, param_obj=param_obj
                         )
-
                 else:
-                    _add_body_or_query_param_field(
-                        body_or_query_param_fields, param_name, param_type_annotation, param_obj=param_obj
-                    )
-            else:
-                raise NotImplementedError(f"Unsupported param 'in': {param_location}")
-        except Exception:
-            logger.error(
-                "Encountered an error while processing a param object in 'parameters':\n"
-                f"- param name: {param_name}\n"
-                f"- param object: {param_obj}"
-            )
-            raise
+                    raise NotImplementedError(f"Unsupported param 'in': {param_location}")
+            except Exception:
+                logger.error(
+                    "Encountered an error while processing a param object in 'parameters':\n"
+                    f"- param name: {param_name}\n"
+                    f"- param object: {param_obj}"
+                )
+                raise
 
 
 def _parse_request_body_object(

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

@@ -90,14 +90,14 @@ def generate_model_name(field_name: str, field_type: str | Any) -> str:
     :param field_name: Dataclass field name
     :param field_type: OpenAPI parameter type or dataclass field type
     """
-    model_name = generate_class_name(field_name)
+    model_name = generate_class_name(clean_model_field_name(field_name))
     # NOTE: You may need to add a custom blacklist/rules for your app in here to ignore words that inflect library
     # doesn't handle well.
     # Eg. The word "bps" (Bits per second) is not a plural word, but inflect thinks it is and incorrectly generates
     # its singular noun as "bp"
     if param_type_util.is_type_of(field_type, list) and (singular_noun := inflect.engine().singular_noun(model_name)):
         # Change the plural model name to the singular word
-        model_name = singular_noun
+        model_name = cast(str, singular_noun)
 
     # Adjust the model name if it happens to conflict with class names we might import, or with the field_name itself
     if model_name in [*get_reserved_model_names(), field_name]:
@@ -320,6 +320,18 @@ def visit(model_name: str) -> None:
     return sorted(models, key=lambda x: sorted_models_names.index(x.__name__))
 
 
+@lru_cache
+def clean_model_field_name(name: str) -> str:
+    """Returns an alias name if the given name is illegal as a model field name"""
+    name = clean_obj_name(name)
+    # NOTE: The escaping of kwargs is already is handled in endpoint model
+    reserved_param_names = ["self", "validate", *get_supported_request_parameters()]
+    if name in get_reserved_model_names() + reserved_param_names:
+        # The field name conflicts with one of reserved names
+        name += "_"
+    return name
+
+
 def alias_illegal_model_field_names(location: str, model_fields: list[DataclassModelField]) -> None:
     """Clean illegal model field name and annotate the field type with Alias class
 
@@ -335,33 +347,14 @@ def make_alias(name: str, param_type: Any) -> str:
         ):
             return name
         else:
-            name = clean_obj_name(name)
-            # NOTE: The escaping of kwargs is already is handled in endpoint model
-            reserved_param_names = ["self", "validate", *get_supported_request_parameters()]
-            if name in get_reserved_model_names() + reserved_param_names:
-                # The field name conflicts with one of reserved names
-                name += "_"
-
+            name = clean_model_field_name(name)
             if param_models := get_param_model(param_type):
-                # There seems to be an issue with the `Annotated` cache behavior. AttributeError will be thrown on
-                # importing the model when the following conditions are all met:
-                # - The model field is annotated with `Annotated`
-                # - The origin type of `Annotated` is another param model, or union of param models (nested model)
-                # - The model field name is identical to one of the annotated model names
-                # eg.
-                #
-                # @dataclass
-                # class NestedModel(ParamModel):
-                #     param: str = Unset
-                #
-                # @dataclass
-                # class Model(ParamModel):
-                #     NestedModel: Annotated[NestedModel, "test"] = Unset
-                #
+                # There seems to be some known issues when the field name clashes with the type annotation name.
+                # We change the field name in this case
+                # eg. https://docs.pydantic.dev/2.10/errors/usage_errors/#unevaluable-type-annotation
                 if not isinstance(param_models, list):
                     param_models = [param_models]
-                if any(name == (m.__forward_arg__ if isinstance(m, ForwardRef) else m.__name__) for m in param_models):
-                    # This meets the above issue conditions
+                if any(name == get_param_model_name(m) for m in param_models):
                     name += "_"
             return name
 

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

@@ -33,7 +33,7 @@
 INT_PARAM_TYPES = ["integer", "int", "int64", "number"]
 BOOL_PARAM_TYPES = ["boolean", "bool"]
 LIST_PARAM_TYPES = ["array"]
-NULL_PARAM_TYPES = ["null"]
+NULL_PARAM_TYPES = ["null", None]
 
 
 def get_type_annotation_as_str(tp: Any) -> str:
@@ -199,7 +199,7 @@ def resolve(param_type: str | Sequence[str], param_format: str | None = None) ->
             # Optional parameter
             type_annotation = generate_optional_type(type_annotation)
 
-    if num_optional_types := repr(type_annotation).count("Optional"):
+    if num_optional_types := repr(type_annotation).count("Optional["):
         # Sanity check for Optional type. If it is annotated with `Optional`, we want it to appear as the origin type
         # only. If this check fails, it means the logic is broke somewhere
         if num_optional_types > 1:

src/openapi_test_client/libraries/common/misc.py

@@ -54,7 +54,7 @@ def get_module_name_by_file_path(file_path: Path) -> str:
         assert is_external_project()
         # Accessing the package file from an external location
         file_path_from_package_dir = _PACKAGE_DIR.name + str(file_path).rsplit(_PACKAGE_DIR.name)[-1]
-    return file_path_from_package_dir.replace(os.sep, ".").replace(".py", "")
+    return file_path_from_package_dir.replace(os.sep, ".").removesuffix(".py")
 
 
 def import_module_from_file_path(file_path: Path) -> ModuleType: