add backward compatibility for exclusiveMinimum and exclusiveMaximum (#1092)

This PR ensures backward compatibility in the schema validator for the
exclusiveMinimum and exclusiveMaximum properties, handling both the
boolean format from OpenAPI v3.0 and the numeric format from v3.1.

Documentation for this can be found here:
https://www.openapis.org/blog/2021/02/16/migrating-from-openapi-3-0-to-3-1-0
under the `Tweak exclusiveMinimum and exclusiveMaximum` section

Changes Made:

- Updated the Schema class to handle both boolean (v3.0) and numeric
(v3.1) formats for exclusiveMinimum and exclusiveMaximum.
- Added a handle_exclusive_min_max method to ensure that the schema is
correctly validated and converted based on the OpenAPI version.
- Added tests to ensure the correct behavior for both formats of
exclusiveMinimum and exclusiveMaximum.

---------

Co-authored-by: Dylan Anthony <dbanty@users.noreply.github.com>
Co-authored-by: Dylan Anthony <43723790+dbanty@users.noreply.github.com>

Author: mikkelam

.changeset/add_backward_compatibility_for_exclusiveminimum_and_exclusivemaximum.md

@@ -0,0 +1,7 @@
+---
+default: patch
+---
+
+# Allow OpenAPI 3.1-style `exclusiveMinimum` and `exclusiveMaximum`
+
+Fixed by PR #1092. Thanks @mikkelam!

openapi_python_client/schema/openapi_schema_pydantic/schema.py

@@ -23,9 +23,9 @@ class Schema(BaseModel):
     title: Optional[str] = None
     multipleOf: Optional[float] = Field(default=None, gt=0.0)
     maximum: Optional[float] = None
-    exclusiveMaximum: Optional[bool] = None
+    exclusiveMaximum: Optional[Union[bool, float]] = None
     minimum: Optional[float] = None
-    exclusiveMinimum: Optional[bool] = None
+    exclusiveMinimum: Optional[Union[bool, float]] = None
     maxLength: Optional[int] = Field(default=None, ge=0)
     minLength: Optional[int] = Field(default=None, ge=0)
     pattern: Optional[str] = None
@@ -160,6 +160,33 @@ class Schema(BaseModel):
         },
     )
 
+    @model_validator(mode="after")
+    def handle_exclusive_min_max(self) -> "Schema":
+        """
+        Convert exclusiveMinimum/exclusiveMaximum between OpenAPI v3.0 (bool) and v3.1 (numeric).
+        """
+        # Handle exclusiveMinimum
+        if isinstance(self.exclusiveMinimum, bool) and self.minimum is not None:
+            if self.exclusiveMinimum:
+                self.exclusiveMinimum = self.minimum
+                self.minimum = None
+            else:
+                self.exclusiveMinimum = None
+        elif isinstance(self.exclusiveMinimum, float):
+            self.minimum = None
+
+        # Handle exclusiveMaximum
+        if isinstance(self.exclusiveMaximum, bool) and self.maximum is not None:
+            if self.exclusiveMaximum:
+                self.exclusiveMaximum = self.maximum
+                self.maximum = None
+            else:
+                self.exclusiveMaximum = None
+        elif isinstance(self.exclusiveMaximum, float):
+            self.maximum = None
+
+        return self
+
     @model_validator(mode="after")
     def handle_nullable(self) -> "Schema":
         """Convert the old 3.0 `nullable` property into the new 3.1 style"""

pyproject.toml

@@ -63,6 +63,7 @@ ignore = ["E501", "PLR0913"]
 
 [tool.ruff.lint.per-file-ignores]
 "openapi_python_client/cli.py" = ["B008"]
+"tests/*" = ["PLR2004"]
 
 [tool.coverage.run]
 omit = ["openapi_python_client/templates/*"]

tests/test_cli.py

@@ -20,7 +20,7 @@ def test_bad_config():
 
     result = runner.invoke(app, ["generate", f"--config={config_path}", f"--path={path}"])
 
-    assert result.exit_code == 2  # noqa: PLR2004
+    assert result.exit_code == 2
     assert "Unable to parse config" in result.stdout
 
 

tests/test_parser/test_openapi.py

@@ -350,7 +350,7 @@ def test__add_parameters_query_optionality(self, config):
             endpoint=endpoint, data=data, schemas=Schemas(), parameters=Parameters(), config=config
         )
 
-        assert len(endpoint.query_parameters) == 2, "Not all query params were added"  # noqa: PLR2004
+        assert len(endpoint.query_parameters) == 2, "Not all query params were added"
         for param in endpoint.query_parameters:
             if param.name == "required":
                 assert param.required

tests/test_parser/test_properties/test_init.py

@@ -688,7 +688,7 @@ def test_property_from_data_union(self, config):
         )[0]
 
         assert isinstance(response, UnionProperty)
-        assert len(response.inner_properties) == 2  # noqa: PLR2004
+        assert len(response.inner_properties) == 2
 
     def test_property_from_data_list_of_types(self, config):
         from openapi_python_client.parser.properties import Schemas, property_from_data
@@ -705,7 +705,7 @@ def test_property_from_data_list_of_types(self, config):
         )[0]
 
         assert isinstance(response, UnionProperty)
-        assert len(response.inner_properties) == 2  # noqa: PLR2004
+        assert len(response.inner_properties) == 2
 
     def test_property_from_data_union_of_one_element(self, model_property_factory, config):
         from openapi_python_client.parser.properties import Schemas, property_from_data
@@ -907,7 +907,7 @@ def test_retries_failing_properties_while_making_progress(self, mocker, config):
                 call("#/components/schemas/first"),
             ]
         )
-        assert update_schemas_with_data.call_count == 3  # noqa: PLR2004
+        assert update_schemas_with_data.call_count == 3
         assert result.errors == [PropertyError()]
 
 
@@ -1171,7 +1171,7 @@ def test_retries_failing_parameters_while_making_progress(self, mocker, config):
                 call("#/components/parameters/first"),
             ]
         )
-        assert update_parameters_with_data.call_count == 3  # noqa: PLR2004
+        assert update_parameters_with_data.call_count == 3
         assert result.errors == [ParameterError()]
 
 

tests/test_schema/test_schema.py

@@ -25,3 +25,39 @@ def test_nullable_with_any_of():
 def test_nullable_with_one_of():
     schema = Schema.model_validate_json('{"oneOf": [{"type": "string"}], "nullable": true}')
     assert schema.oneOf == [Schema(type=DataType.STRING), Schema(type=DataType.NULL)]
+
+
+def test_exclusive_minimum_as_boolean():
+    schema = Schema.model_validate_json('{"minimum": 10, "exclusiveMinimum": true}')
+    assert schema.exclusiveMinimum == 10
+    assert schema.minimum is None
+
+
+def test_exclusive_maximum_as_boolean():
+    schema = Schema.model_validate_json('{"maximum": 100, "exclusiveMaximum": true}')
+    assert schema.exclusiveMaximum == 100
+    assert schema.maximum is None
+
+
+def test_exclusive_minimum_as_number():
+    schema = Schema.model_validate_json('{"exclusiveMinimum": 5}')
+    assert schema.exclusiveMinimum == 5
+    assert schema.minimum is None
+
+
+def test_exclusive_maximum_as_number():
+    schema = Schema.model_validate_json('{"exclusiveMaximum": 50}')
+    assert schema.exclusiveMaximum == 50
+    assert schema.maximum is None
+
+
+def test_exclusive_minimum_as_false_boolean():
+    schema = Schema.model_validate_json('{"minimum": 10, "exclusiveMinimum": false}')
+    assert schema.exclusiveMinimum is None
+    assert schema.minimum == 10
+
+
+def test_exclusive_maximum_as_false_boolean():
+    schema = Schema.model_validate_json('{"maximum": 100, "exclusiveMaximum": false}')
+    assert schema.exclusiveMaximum is None
+    assert schema.maximum == 100