Fixes linter issues and a failing test with the latest changes.

Author: Jordi Sanchez

openapi_python_client/parser/openapi.py

@@ -23,7 +23,7 @@
     build_schemas,
     property_from_data,
 )
-from .properties.schemas import parse_reference_path
+from .properties.schemas import parameter_from_reference
 from .responses import Response, response_from_data
 
 _PATH_PARAM_REGEX = re.compile("{([a-zA-Z_][a-zA-Z0-9_]*)}")
@@ -293,6 +293,8 @@ def add_parameters(
             - https://swagger.io/docs/specification/describing-parameters/
             - https://swagger.io/docs/specification/paths-and-operations/
         """
+        # pylint: disable=too-many-branches, too-many-locals
+        # There isn't much value in breaking down this function further other than to satisfy the linter.
 
         if data.parameters is None:
             return endpoint, schemas, parameters
@@ -307,35 +309,32 @@ def add_parameters(
             oai.ParameterLocation.COOKIE: endpoint.cookie_parameters,
         }
 
-        for _param in data.parameters:
-            param: oai.Parameter
+        for param in data.parameters:
+            # Obtain the parameter from the reference or just the parameter itself
+            param_or_error = parameter_from_reference(param=param, parameters=parameters)
+            if isinstance(param_or_error, ParseError):
+                return param_or_error, schemas, parameters
+            param = param_or_error
 
-            if _param is None:
-                return ParseError(data=data, detail="Null parameter provided."), schemas, parameters
-
-            if isinstance(_param, oai.Reference):
-                ref_path = parse_reference_path(_param.ref)
-                if isinstance(ref_path, ParseError):
-                    return ref_path, schemas, parameters
-                _resolved_class = parameters.classes_by_reference.get(ref_path)
-                if _resolved_class is None:
-                    return ParseError(data=data, detail=f"Reference `{ref_path}` not found."), schemas, parameters
-                param = _resolved_class
-            elif isinstance(_param, oai.Parameter):
-                param = _param
+            if param.param_schema is None:
+                continue
 
             unique_param = (param.name, param.param_in)
-            if unique_param in unique_parameters:
-                duplication_detail = (
-                    "Parameters MUST NOT contain duplicates. "
-                    "A unique parameter is defined by a combination of a name and location. "
-                    f"Duplicated parameters named `{param.name}` detected in `{param.param_in}`."
+            if (param.name, param.param_in) in unique_parameters:
+                return (
+                    ParseError(
+                        data=data,
+                        detail=(
+                            "Parameters MUST NOT contain duplicates. "
+                            "A unique parameter is defined by a combination of a name and location. "
+                            f"Duplicated parameters named `{param.name}` detected in `{param.param_in}`."
+                        ),
+                    ),
+                    schemas,
+                    parameters,
                 )
-                return ParseError(data=data, detail=duplication_detail), schemas, parameters
-            unique_parameters.add(unique_param)
 
-            if param.param_schema is None:
-                continue
+            unique_parameters.add(unique_param)
 
             prop, new_schemas = property_from_data(
                 name=param.name,

openapi_python_client/parser/properties/schemas.py

@@ -1,4 +1,11 @@
-__all__ = ["Class", "Schemas", "Parameters", "parse_reference_path", "update_schemas_with_data"]
+__all__ = [
+    "Class",
+    "Schemas",
+    "Parameters",
+    "parse_reference_path",
+    "update_schemas_with_data",
+    "parameter_from_reference",
+]
 
 from typing import TYPE_CHECKING, Dict, List, NewType, Tuple, Union, cast
 from urllib.parse import urlparse
@@ -190,3 +197,35 @@ def update_parameters_with_data(
 
     parameters = attr.evolve(parameters, classes_by_reference={ref_path: param, **parameters.classes_by_reference})
     return parameters
+
+
+def parameter_from_reference(
+    *,
+    param: Union[oai.Reference, Parameter],
+    parameters: Parameters,
+) -> Union[Parameter, ParameterError]:
+    """
+    Returns a Parameter from a Reference or the Parameter itself if one was provided.
+
+    Args:
+        param: A parameter by `Reference`.
+        parameters: `Parameters` up until now.
+
+    Returns:
+        Either the updated `schemas` input or a `PropertyError` if something went wrong.
+
+    See Also:
+        - https://swagger.io/docs/specification/using-ref/
+    """
+    if isinstance(param, Parameter):
+        return param
+
+    ref_path = parse_reference_path(param.ref)
+
+    if isinstance(ref_path, ParseError):
+        return ParameterError(detail=ref_path.detail)
+
+    _resolved_parameter_class = parameters.classes_by_reference.get(ref_path, None)
+    if _resolved_parameter_class is None:
+        return ParameterError(detail=f"Reference `{ref_path}` not found.")
+    return _resolved_parameter_class

tests/test_parser/test_openapi.py

@@ -707,7 +707,7 @@ def test__add_parameters_resolves_references(self, mocker, param_factory):
         )
 
         parameters = mocker.MagicMock()
-        new_param = param_factory(name="blah")
+        new_param = param_factory(name="blah", schema=oai.Schema.construct(nullable=False, type="string"))
         parameters.classes_by_name = {
             "blah": new_param,
         }