voluptuous-openapi 0.2.0__tar.gz → 0.3.0__tar.gz

{voluptuous_openapi-0.2.0/voluptuous_openapi.egg-info → voluptuous_openapi-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voluptuous-openapi
-Version: 0.2.0
+Version: 0.3.0
 Summary: Convert voluptuous schemas to OpenAPI Schema object
 Author-email: Denis Shulyaka <Shulyaka@gmail.com>
 License-Expression: Apache-2.0

{voluptuous_openapi-0.2.0 → voluptuous_openapi-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools>=77.0"]
 
 [project]
 name = "voluptuous-openapi"
-version = "0.2.0"
+version = "0.3.0"
 license = "Apache-2.0"
 description = "Convert voluptuous schemas to OpenAPI Schema object"
 readme = "README.md"

{voluptuous_openapi-0.2.0 → voluptuous_openapi-0.3.0}/tests/test_lib.py

@@ -410,6 +410,11 @@ def test_key_any():
         },
         "required": [],
         "type": "object",
+        "anyOf": [
+            {"required": ["hours"]},
+            {"required": ["minutes"]},
+            {"required": ["seconds"]},
+        ],
     } == convert(
         {
             vol.Required(vol.Any("hours", "minutes", "seconds")): int,
@@ -830,3 +835,184 @@ def test_convert_to_voluptuous_nullable_number_with_range():
 
     with pytest.raises(vol.Invalid):
         validator(101.0)  # too high
+
+
+TEST_TASK_ITEM = {"content": "a task ", "description": "a description"}
+TASK_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "tasks": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "content": {
+                        "type": "string",
+                        "description": "The content of the task to create.",
+                    },
+                    "description": {
+                        "type": "string",
+                        "description": "The description of the task.",
+                    },
+                },
+                "required": ["content"],
+                "additionalProperties": False,
+            },
+        }
+    },
+}
+
+
+@pytest.mark.parametrize(
+    "extra_tasks_data, input_data",
+    [
+        ({"minItems": 1, "maxItems": 2}, {"tasks": [TEST_TASK_ITEM]}),
+        ({"minItems": 1, "maxItems": 2}, {"tasks": [TEST_TASK_ITEM, TEST_TASK_ITEM]}),
+        ({"minItems": 1}, {"tasks": [TEST_TASK_ITEM]}),
+        ({"maxItems": 2}, {"tasks": [TEST_TASK_ITEM, TEST_TASK_ITEM]}),
+    ],
+)
+def test_with_min_max_items_success(extra_tasks_data, input_data):
+    task_schema = TASK_SCHEMA.copy()
+    task_schema["properties"]["tasks"].update(extra_tasks_data)
+
+    validator = convert_to_voluptuous(task_schema)
+
+    validator(input_data)
+
+
+@pytest.mark.parametrize(
+    "extra_tasks_data, input_data",
+    [
+        ({"minItems": 1, "maxItems": 2}, {"tasks": []}),
+        (
+            {"minItems": 1, "maxItems": 2},
+            {"tasks": [TEST_TASK_ITEM, TEST_TASK_ITEM, TEST_TASK_ITEM]},
+        ),
+        ({"minItems": 1}, {"tasks": []}),
+        ({"maxItems": 2}, {"tasks": [TEST_TASK_ITEM, TEST_TASK_ITEM, TEST_TASK_ITEM]}),
+    ],
+)
+def test_with_min_max_items_fails_validation(extra_tasks_data, input_data):
+    task_schema = TASK_SCHEMA.copy()
+    task_schema["properties"]["tasks"].update(extra_tasks_data)
+
+    validator = convert_to_voluptuous(task_schema)
+
+    with pytest.raises(vol.Invalid):
+        validator(input_data)
+
+
+def test_required_any_of():
+    """Test schemas with Required(Any(...)) constraints."""
+    assert {
+        "properties": {
+            "color": {"type": "string"},
+            "temperature": {"type": "integer"},
+            "brightness": {"type": "integer"},
+        },
+        "required": [],
+        "type": "object",
+        "anyOf": [
+            {"required": ["color"]},
+            {"required": ["temperature"]},
+            {"required": ["brightness"]},
+        ],
+    } == convert(
+        {
+            vol.Required(vol.Any("color", "temperature", "brightness")): object,
+            vol.Optional("color"): str,
+            vol.Optional("temperature"): int,
+            vol.Optional("brightness"): int,
+        }
+    )
+
+    assert {
+        "properties": {
+            "color": {"type": "string"},
+            "temperature": {"type": "integer"},
+            "brightness": {"type": "integer"},
+            "mode": {"type": "string"},
+            "preset": {"type": "string"},
+        },
+        "required": [],
+        "type": "object",
+        "anyOf": [
+            {"required": ["color", "mode"]},
+            {"required": ["color", "preset"]},
+            {"required": ["temperature", "mode"]},
+            {"required": ["temperature", "preset"]},
+            {"required": ["brightness", "mode"]},
+            {"required": ["brightness", "preset"]},
+        ],
+    } == convert(
+        {
+            vol.Required(vol.Any("color", "temperature", "brightness")): object,
+            vol.Required(vol.Any("mode", "preset")): str,
+            vol.Optional("color"): str,
+            vol.Optional("temperature"): int,
+            vol.Optional("brightness"): int,
+            vol.Optional("mode"): str,
+            vol.Optional("preset"): str,
+        }
+    )
+
+    assert {
+        "properties": {
+            "entity_id": {"type": "string"},
+            "color": {"type": "string"},
+            "temperature": {"type": "integer"},
+        },
+        "required": ["entity_id"],
+        "type": "object",
+        "anyOf": [{"required": ["color"]}, {"required": ["temperature"]}],
+    } == convert(
+        {
+            vol.Required("entity_id"): str,
+            vol.Required(vol.Any("color", "temperature")): str,
+            vol.Optional("color"): str,
+            vol.Optional("temperature"): int,
+        }
+    )
+
+
+def test_required_any_of_description():
+    """Test that the description is preserved in a Required(Any(...)) constraint."""
+    assert {
+        "properties": {
+            "color": {"type": "string", "description": "Light appearance"},
+            "temperature": {"type": "string", "description": "Light appearance"},
+        },
+        "required": [],
+        "type": "object",
+        "anyOf": [{"required": ["color"]}, {"required": ["temperature"]}],
+    } == convert(
+        {
+            vol.Required(
+                vol.Any("color", "temperature"), description="Light appearance"
+            ): str,
+        }
+    )
+
+
+def test_required_any_of_inner_description():
+    """Test that inner descriptions are preferred in a Required(Any(...)) constraint."""
+    assert {
+        "properties": {
+            "color": {"type": "string", "description": "Inner color description"},
+            "temperature": {"type": "string", "description": "Outer description"},
+        },
+        "required": [],
+        "type": "object",
+        "anyOf": [{"required": ["color"]}, {"required": ["temperature"]}],
+    } == convert(
+        {
+            vol.Required(
+                vol.Any(
+                    vol.Optional("color", description="Inner color description"),
+                    "temperature",
+                ),
+                description="Outer description",
+            ): str,
+        }
+    )

{voluptuous_openapi-0.2.0 → voluptuous_openapi-0.3.0}/tests/test_validation.py

@@ -576,3 +576,70 @@ def test_maybe(validator: Validator) -> None:
 
     with pytest.raises(InvalidFormat):
         validator({"key": "value"})
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {
+            "type": "object",
+            "properties": {
+                "color": {"type": "string"},
+                "temperature": {"type": "integer"},
+                "brightness": {
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 100,
+                },
+            },
+            "anyOf": [
+                {"required": ["color"]},
+                {"required": ["temperature"]},
+                {"required": ["brightness"]},
+            ],
+        },
+        vol.Schema(
+            {
+                vol.Required(vol.Any("color", "temperature", "brightness")): object,
+                vol.Optional("color"): str,
+                vol.Optional("temperature"): int,
+                vol.Optional("brightness"): vol.All(int, vol.Range(min=0, max=100)),
+            }
+        ),
+    ),
+    ids=TEST_IDS,
+)
+def test_any_of_constraint(validator: Validator) -> None:
+    """Test anyOf constraint for requiring at least one of multiple properties."""
+    # Test valid cases
+    validator({"color": "red"})
+    validator({"temperature": 20})
+    validator({"brightness": 80})
+    validator({"brightness": 0})
+    validator({"brightness": 100})
+    validator({"color": "blue", "temperature": 25})
+    validator({"color": "green", "brightness": 100})
+    validator({"temperature": 22, "brightness": 90})
+    validator({"color": "purple", "temperature": 21, "brightness": 70})
+
+    # Test invalid cases
+    with pytest.raises(InvalidFormat):
+        validator({})  # Missing all required properties
+
+    with pytest.raises(InvalidFormat):
+        validator({"other_field": "value"})  # Missing all required properties
+
+    with pytest.raises(InvalidFormat):
+        validator({"brightness": -1})  # Out of range
+
+    with pytest.raises(InvalidFormat):
+        validator({"brightness": 101})  # Out of range
+
+    with pytest.raises(InvalidFormat):
+        validator({"brightness": "abc"})  # Wrong type
+
+    with pytest.raises(InvalidFormat):
+        validator({"color": 123})  # Wrong type
+
+    with pytest.raises(InvalidFormat):
+        validator({"temperature": "abc"})  # Wrong type

{voluptuous_openapi-0.2.0 → voluptuous_openapi-0.3.0}/voluptuous_openapi/__init__.py

@@ -3,6 +3,7 @@
 from collections.abc import Callable, Mapping, Sequence
 from inspect import signature
 from enum import Enum, StrEnum
+import itertools
 import re
 from typing import Any, TypeVar, Union, get_args, get_origin, get_type_hints
 from types import NoneType, UnionType
@@ -24,8 +25,6 @@ UNSUPPORTED = object()
 OPENAPI_UNSUPPORTED_KEYWORDS = {
     "allOf",
     "multipleOf",
-    "minItems",
-    "maxItems",
     "uniqueItems",
 }
 
@@ -88,6 +87,9 @@ def convert(
     if isinstance(schema, Mapping):
         properties = {}
         required = []
+        any_of_constraint_groups: list[list[str]] = (
+            []
+        )  # List of lists, each containing candidate keys for a Required(Any(...))
 
         for key, value in schema.items():
             description = None
@@ -101,22 +103,57 @@ def convert(
             if description:
                 pval["description"] = key.description
 
-            if isinstance(key, (vol.Required, vol.Optional)):
+            if isinstance(key, vol.Required):
+                if not isinstance(key.schema, vol.Any):
+                    required.append(str(key.schema))
+                if key.default is not vol.UNDEFINED:
+                    pval["default"] = key.default()
+            elif isinstance(key, vol.Optional):
                 if key.default is not vol.UNDEFINED:
                     pval["default"] = key.default()
 
             pval = ensure_default(pval)
 
             if isinstance(pkey, vol.Any):
-                for val in pkey.validators:
-                    if isinstance(val, vol.Marker):
-                        if val.description:
-                            properties[str(val.schema)] = pval.copy()
-                            properties[str(val.schema)]["description"] = val.description
+                # Handle Required(Any(...)) pattern for anyOf constraints
+                if isinstance(key, vol.Required):
+                    # Extract candidate keys and their descriptions from Any validator
+                    candidate_items = []
+                    for val_item in pkey.validators:
+                        item_key = ""
+                        item_desc = None
+                        if isinstance(val_item, vol.Marker):
+                            item_key = str(val_item.schema)
+                            item_desc = val_item.description
                         else:
-                            properties[str(val)] = pval
-                    else:
-                        properties[str(val)] = pval
+                            item_key = str(val_item)
+                        candidate_items.append({"key": item_key, "desc": item_desc})
+
+                    candidate_keys = [item["key"] for item in candidate_items]
+                    any_of_constraint_groups.append(candidate_keys)
+
+                    # If the value is not a wildcard, create properties for each
+                    # candidate key, preserving any descriptions.
+                    if value is not object:
+                        for item in candidate_items:
+                            prop_schema = pval.copy()
+                            final_description = item["desc"] or description
+                            if final_description:
+                                prop_schema["description"] = final_description
+                            properties[item["key"]] = prop_schema
+                else:
+                    # Handle Optional(Any(...)) - expand to individual properties
+                    for val_item in pkey.validators:
+                        if isinstance(val_item, vol.Marker):
+                            if val_item.description:
+                                properties[str(val_item.schema)] = pval.copy()
+                                properties[str(val_item.schema)][
+                                    "description"
+                                ] = val_item.description
+                            else:
+                                properties[str(val_item)] = pval
+                        else:
+                            properties[str(val_item)] = pval
             elif isinstance(pkey, str):
                 properties[pkey] = pval
             else:
@@ -126,15 +163,21 @@ def convert(
                 if additional_properties is None:
                     additional_properties = pval
 
-            if isinstance(key, vol.Required) and not isinstance(pkey, vol.Any):
-                required.append(str(pkey))
-
         val = {"type": "object"}
         if properties or not additional_properties:
             val["properties"] = properties
             val["required"] = required
         if additional_properties:
             val["additionalProperties"] = additional_properties
+
+        # Generate anyOf constraints from the Cartesian product of constraint groups
+        if any_of_constraint_groups:
+            # Generate all combinations (Cartesian product) of the constraint groups
+            val["anyOf"] = [
+                {"required": list(combination)}
+                for combination in itertools.product(*any_of_constraint_groups)
+            ]
+
         return val
 
     if isinstance(schema, vol.All):
@@ -426,7 +469,16 @@ def convert_to_voluptuous(schema: dict) -> vol.Schema:
     if (any_of := schema.get("anyOf")) is not None:
         if not isinstance(any_of, list):
             raise ValueError("Invalid schema, anyOf should be a list")
-        return vol.Any(*[convert_to_voluptuous(sub_schema) for sub_schema in any_of])
+        # If the anyOf is a list of required properties, it's a constraint on an
+        # object and should be handled by the object validator.
+        is_required_constraint = all(
+            list(s.keys()) == ["required"] and isinstance(s["required"], list)
+            for s in any_of
+        )
+        if not (is_required_constraint and schema.get("type") == "object"):
+            return vol.Any(
+                *[convert_to_voluptuous(sub_schema) for sub_schema in any_of]
+            )
 
     if (schema_type := schema.get("type")) is None:
         raise ValueError("Invalid schema, missing type")
@@ -491,6 +543,13 @@ def convert_to_voluptuous(schema: dict) -> vol.Schema:
                 key_type = vol.Optional
             properties[key_type(key, description=description)] = value_type
 
+        if (any_of := schema.get("anyOf")) is not None:
+            any_of_keys = [
+                key for sub_schema in any_of for key in sub_schema.get("required", [])
+            ]
+            if any_of_keys:
+                properties[vol.Required(vol.Any(*any_of_keys))] = object
+
         validator = None
         if schema.get("additionalProperties") is True:
             validator = vol.Schema(properties, extra=vol.ALLOW_EXTRA)
@@ -504,7 +563,16 @@ def convert_to_voluptuous(schema: dict) -> vol.Schema:
         return validator
 
     if schema_type == "array":
-        validator = vol.Schema([convert_to_voluptuous(schema["items"])])
+        item_validator = convert_to_voluptuous(schema["items"])
+        min_items = schema.get("minItems")
+        max_items = schema.get("maxItems")
+
+        if min_items is not None or max_items is not None:
+            validator = vol.Schema(
+                vol.All([item_validator], vol.Length(min=min_items, max=max_items))
+            )
+        else:
+            validator = vol.Schema([item_validator])
 
         # Handle OpenAPI 3.0 nullable property
         if schema.get("nullable") is True:

{voluptuous_openapi-0.2.0 → voluptuous_openapi-0.3.0/voluptuous_openapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voluptuous-openapi
-Version: 0.2.0
+Version: 0.3.0
 Summary: Convert voluptuous schemas to OpenAPI Schema object
 Author-email: Denis Shulyaka <Shulyaka@gmail.com>
 License-Expression: Apache-2.0