feat: support #/components/parameters references.

end_to_end_tests/custom-templates-golden-record/my_test_api_client/api/__init__.py

@@ -4,6 +4,7 @@
 
 from .default import DefaultEndpoints
 from .location import LocationEndpoints
+from .parameter_references import ParameterReferencesEndpoints
 from .parameters import ParametersEndpoints
 from .responses import ResponsesEndpoints
 from .tag1 import Tag1Endpoints
@@ -39,3 +40,7 @@ def location(cls) -> Type[LocationEndpoints]:
     @classmethod
     def true_(cls) -> Type[True_Endpoints]:
         return True_Endpoints
+
+    @classmethod
+    def parameter_references(cls) -> Type[ParameterReferencesEndpoints]:
+        return ParameterReferencesEndpoints

end_to_end_tests/custom-templates-golden-record/my_test_api_client/api/parameter_references/__init__.py

@@ -0,0 +1,14 @@
+""" Contains methods for accessing the API Endpoints """
+
+import types
+
+from . import get_parameter_references_path_param
+
+
+class ParameterReferencesEndpoints:
+    @classmethod
+    def get_parameter_references_path_param(cls) -> types.ModuleType:
+        """
+        Test different types of parameter references
+        """
+        return get_parameter_references_path_param

end_to_end_tests/golden-record/my_test_api_client/api/parameter_references/get_parameter_references_path_param.py

@@ -0,0 +1,126 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    path_param: str,
+    *,
+    client: Client,
+    string_param: str,
+    integer_param: int = 0,
+    header_param: str,
+    cookie_param: str,
+) -> Dict[str, Any]:
+    url = "{}/parameter-references/{path_param}".format(client.base_url, path_param=path_param)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    headers["header param"] = header_param
+
+    cookies["cookie param"] = cookie_param
+
+    params: Dict[str, Any] = {}
+    params["string param"] = string_param
+
+    params["integer param"] = integer_param
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    return {
+        "method": "get",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "params": params,
+    }
+
+
+def _build_response(*, response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=None,
+    )
+
+
+def sync_detailed(
+    path_param: str,
+    *,
+    client: Client,
+    string_param: str,
+    integer_param: int = 0,
+    header_param: str,
+    cookie_param: str,
+) -> Response[Any]:
+    """Test different types of parameter references
+
+    Args:
+        path_param (str):
+        string_param (str):
+        integer_param (int):
+        header_param (str):
+        cookie_param (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        path_param=path_param,
+        client=client,
+        string_param=string_param,
+        integer_param=integer_param,
+        header_param=header_param,
+        cookie_param=cookie_param,
+    )
+
+    response = httpx.request(
+        verify=client.verify_ssl,
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    path_param: str,
+    *,
+    client: Client,
+    string_param: str,
+    integer_param: int = 0,
+    header_param: str,
+    cookie_param: str,
+) -> Response[Any]:
+    """Test different types of parameter references
+
+    Args:
+        path_param (str):
+        string_param (str):
+        integer_param (int):
+        header_param (str):
+        cookie_param (str):
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        path_param=path_param,
+        client=client,
+        string_param=string_param,
+        integer_param=integer_param,
+        header_param=header_param,
+        cookie_param=cookie_param,
+    )
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(response=response)

end_to_end_tests/openapi.json

@@ -1082,6 +1082,30 @@
           }
         }
       }
+    },
+    "/parameter-references/{path_param}": {
+      "get": {
+        "tags": [
+          "parameter-references"
+        ],
+        "summary": "Test different types of parameter references",
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/string-param"
+          },
+          {
+            "$ref": "#/components/parameters/integer-param"
+          },
+          {"$ref": "#/components/parameters/header-param"},
+          {"$ref": "#/components/parameters/cookie-param"},
+          {"$ref": "#/components/parameters/path-param"}
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful response"
+          }
+        }
+      }
     }
   },
   "components": {
@@ -1956,6 +1980,70 @@
         "type": "object",
         "description": "A Model with periods in its reference"
       }
+    },
+    "parameters": {
+      "integer-param": {
+        "name": "integer param",
+        "in": "query",
+        "required": false,
+        "style": "form",
+        "explode": true,
+        "schema": {
+          "type": "integer",
+          "default": 0
+        }
+      },
+      "string-param": {
+        "name": "string param",
+        "in": "query",
+        "required": false,
+        "style": "form",
+        "explode": true,
+        "schema": {
+          "type": "string"
+        }
+      },
+      "object-param": {
+        "name": "object param",
+        "in": "query",
+        "required": false,
+        "schema": {
+          "type": "object",
+          "properties": {
+            "date": {
+              "type": "string",
+              "format": "date"
+            },
+            "number": {
+              "type": "number"
+            }
+          }
+        }
+      },
+      "header-param": {
+        "name": "header param",
+        "in": "header",
+        "required": false,
+        "schema": {
+          "type": "string"
+        }
+      },
+      "cookie-param": {
+        "name": "cookie param",
+        "in": "cookie",
+        "required": false,
+        "schema": {
+          "type": "string"
+        }
+      },
+      "path-param": {
+        "name": "path_param",
+        "in": "path",
+        "required": true,
+        "schema": {
+          "type": "string"
+        }
+      }
     }
   }
 }

openapi_python_client/parser/errors.py

@@ -2,7 +2,7 @@
 from enum import Enum
 from typing import Optional
 
-__all__ = ["ErrorLevel", "GeneratorError", "ParseError", "PropertyError", "ValidationError"]
+__all__ = ["ErrorLevel", "GeneratorError", "ParseError", "PropertyError", "ValidationError", "ParameterError"]
 
 from pydantic import BaseModel
 
@@ -39,5 +39,12 @@ class PropertyError(ParseError):
     header = "Problem creating a Property: "
 
 
+@dataclass
+class ParameterError(ParseError):
+    """Error raised when there's a problem creating a Parameter."""
+
+    header = "Problem creating a Parameter: "
+
+
 class ValidationError(Exception):
     """Used internally to exit quickly from property parsing due to some internal exception."""