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

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

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

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

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

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

@@ -4,7 +4,12 @@ from typing import Any, TypeVar
 import pytest
 import voluptuous as vol
 
-from voluptuous_openapi import UNSUPPORTED, convert, convert_to_voluptuous
+from voluptuous_openapi import (
+    UNSUPPORTED,
+    convert,
+    convert_to_voluptuous,
+    OpenApiVersion,
+)
 
 
 def test_int_schema():
@@ -226,6 +231,15 @@ def test_maybe():
     } == convert(vol.Schema(vol.Maybe(str)))
 
 
+def test_maybe_v3_1():
+    assert {
+        "anyOf": [
+            {"type": "null"},
+            {"type": "string"},
+        ],
+    } == convert(vol.Schema(vol.Maybe(str)), openapi_version=OpenApiVersion.V3_1)
+
+
 def test_custom_serializer():
     def custem_serializer(schema):
         if schema is str:
@@ -257,6 +271,12 @@ def test_constant():
         "nullable": True,
         "description": "Must be null",
     } == convert(vol.Schema(type(None)))
+    assert {
+        "type": "null",
+    } == convert(vol.Schema(None), openapi_version=OpenApiVersion.V3_1)
+    assert {
+        "type": "null",
+    } == convert(vol.Schema(type(None)), openapi_version=OpenApiVersion.V3_1)
 
 
 def test_enum():
@@ -327,6 +347,11 @@ def test_any_of():
         "anyOf": [{"type": "number"}, {"type": "integer"}],
         "nullable": True,
     } == convert(vol.Any(vol.Maybe(float), vol.Maybe(int)))
+    assert {
+        "anyOf": [{"type": "null"}, {"type": "number"}, {"type": "integer"}],
+    } == convert(
+        vol.Any(vol.Maybe(float), vol.Maybe(int)), openapi_version=OpenApiVersion.V3_1
+    )
 
 
 def test_all_of():
@@ -421,6 +446,9 @@ def test_function():
     assert {"type": "number", "nullable": True} == convert(
         vol.Schema(validator_nullable)
     )
+    assert {"anyOf": [{"type": "number"}, {"type": "null"}]} == convert(
+        vol.Schema(validator_nullable), openapi_version=OpenApiVersion.V3_1
+    )
 
     def validator_union(data: float | int):
         return data
@@ -606,3 +634,199 @@ def test_convert_to_voluptuous_marker_description(required: list[str]):
         ("query", "The query to search for"),
         ("max_results", "The maximum number of results to return"),
     ]
+
+
+def test_convert_to_voluptuous_nullable_string_openapi_3_0():
+    """Test OpenAPI 3.0 nullable string."""
+    validator = convert_to_voluptuous({"type": "string", "nullable": True})
+    validator("test")
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator(123)
+
+
+def test_convert_to_voluptuous_non_nullable_string_openapi_3_0():
+    """Test OpenAPI 3.0 non-nullable string."""
+    validator_type = convert_to_voluptuous({"type": "string", "nullable": False})
+    # Wrap in a Schema for proper validation
+    validator = vol.Schema(validator_type)
+    validator("test")
+    validator("")  # empty string should be valid
+
+    with pytest.raises(vol.Invalid):
+        validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator(123)
+
+
+def test_convert_to_voluptuous_nullable_integer_openapi_3_0():
+    """Test OpenAPI 3.0 nullable integer."""
+    validator = convert_to_voluptuous({"type": "integer", "nullable": True})
+    validator(42)
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator("string")
+
+
+def test_convert_to_voluptuous_nullable_number_openapi_3_0():
+    """Test OpenAPI 3.0 nullable number."""
+    validator = convert_to_voluptuous({"type": "number", "nullable": True})
+    validator(3.14)
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator("string")
+
+
+def test_convert_to_voluptuous_nullable_boolean_openapi_3_0():
+    """Test OpenAPI 3.0 nullable boolean."""
+    validator = convert_to_voluptuous({"type": "boolean", "nullable": True})
+    validator(True)
+    validator(False)
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator("string")
+
+
+def test_convert_to_voluptuous_nullable_object_openapi_3_0():
+    """Test OpenAPI 3.0 nullable object."""
+    validator = convert_to_voluptuous(
+        {"type": "object", "properties": {"name": {"type": "string"}}, "nullable": True}
+    )
+    validator({"name": "test"})
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator("string")
+
+
+def test_convert_to_voluptuous_nullable_array_openapi_3_0():
+    """Test OpenAPI 3.0 nullable array."""
+    validator = convert_to_voluptuous(
+        {"type": "array", "items": {"type": "string"}, "nullable": True}
+    )
+    validator(["a", "b"])
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator("string")
+
+
+def test_convert_to_voluptuous_nullable_string_openapi_3_1():
+    """Test OpenAPI 3.1 nullable string using type array."""
+    validator = convert_to_voluptuous({"type": ["string", "null"]})
+    validator("test")
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator(123)
+
+
+def test_convert_to_voluptuous_nullable_integer_openapi_3_1():
+    """Test OpenAPI 3.1 nullable integer using type array."""
+    validator = convert_to_voluptuous({"type": ["integer", "null"]})
+    validator(42)
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator("string")
+
+
+def test_convert_to_voluptuous_multiple_types_with_null_openapi_3_1():
+    """Test OpenAPI 3.1 multiple types with null."""
+    validator = convert_to_voluptuous({"type": ["string", "integer", "null"]})
+    validator("test")
+    validator(42)
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator(3.14)
+
+
+def test_convert_to_voluptuous_multiple_types_without_null_openapi_3_1():
+    """Test OpenAPI 3.1 multiple types without null."""
+    validator = convert_to_voluptuous({"type": ["string", "integer"]})
+    validator("test")
+    validator(42)
+
+    with pytest.raises(vol.Invalid):
+        validator(None)
+
+
+def test_convert_to_voluptuous_only_null_openapi_3_1():
+    """Test OpenAPI 3.1 type array with only null."""
+    validator = convert_to_voluptuous({"type": ["null"]})
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator("test")
+
+
+def test_convert_to_voluptuous_nullable_string_with_pattern():
+    """Test nullable string with pattern constraint."""
+    validator = convert_to_voluptuous(
+        {"type": "string", "pattern": r"^test", "nullable": True}
+    )
+    validator("testing")
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator("nottest")
+
+
+def test_convert_to_voluptuous_nullable_integer_with_range_openapi_3_0():
+    """Test nullable integer with range constraint (OpenAPI 3.0 style)."""
+    validator = convert_to_voluptuous(
+        {"type": "integer", "minimum": 1, "maximum": 10, "nullable": True}
+    )
+    validator(5)
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator(15)
+
+
+def test_convert_to_voluptuous_nullable_integer_with_range_openapi_3_1():
+    """Test nullable integer with range constraint (OpenAPI 3.1 style)."""
+    validator = convert_to_voluptuous(
+        {"type": ["integer", "null"], "minimum": 1, "maximum": 10}
+    )
+    validator(5)
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator(15)
+
+
+def test_convert_to_voluptuous_nullable_string_with_length_constraints():
+    """Test nullable string with length constraints."""
+    validator = convert_to_voluptuous(
+        {"type": "string", "minLength": 3, "maxLength": 10, "nullable": True}
+    )
+    validator("hello")
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator("hi")  # too short
+
+    with pytest.raises(vol.Invalid):
+        validator("verylongstring")  # too long
+
+
+def test_convert_to_voluptuous_nullable_number_with_range():
+    """Test nullable number with range constraints."""
+    validator = convert_to_voluptuous(
+        {"type": "number", "minimum": 0.0, "maximum": 100.0, "nullable": True}
+    )
+    validator(50.5)
+    validator(None)
+
+    with pytest.raises(vol.Invalid):
+        validator(-1.0)  # too low
+
+    with pytest.raises(vol.Invalid):
+        validator(101.0)  # too high

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

@@ -9,7 +9,6 @@ and are tested by exercising with both valid and invalid data.
 """
 
 from collections.abc import Callable, Generator
-import datetime
 
 import pytest
 import voluptuous as vol
@@ -17,7 +16,7 @@ import openapi_schema_validator
 from typing import Any
 import logging
 
-from voluptuous_openapi import convert, convert_to_voluptuous
+from voluptuous_openapi import convert, convert_to_voluptuous, OpenApiVersion
 from jsonschema.exceptions import ValidationError
 
 
@@ -36,7 +35,7 @@ def voluptuous_validator(schema: vol.Schema) -> Validator:
 
     def validator(data: Any) -> Any:
         try:
-            _LOGGER.debug("Validating %s with schema %s", data, schema)
+            _LOGGER.debug("Validating voluptuous %s with schema %s", data, schema)
             return schema(data)
         except (vol.Invalid, ValueError) as e:
             raise InvalidFormat(str(e))
@@ -49,7 +48,7 @@ def openapi_validator(schema: dict) -> Any:
 
     def validator(data: Any) -> Any:
         try:
-            _LOGGER.debug("Validating %s with schema %s", data, schema)
+            _LOGGER.debug("Validating openai %s with schema %s", data, schema)
             openapi_schema_validator.validate(data, schema)
             return data
         except ValidationError as e:
@@ -71,8 +70,11 @@ def generate_validators(
     yield openapi_validator(openapi_schema)
     yield voluptuous_validator(voluptuous_schema)
 
-    # Converted schema validations
-    yield openapi_validator(convert(voluptuous_schema))
+    # Converted schema validations. We use OpenAPI version 3.1 because it has equivalent
+    # semantics to voluptuous.
+    yield openapi_validator(
+        convert(voluptuous_schema, openapi_version=OpenApiVersion.V3_1)
+    )
     yield voluptuous_validator(convert_to_voluptuous(openapi_schema))
 
 
@@ -343,6 +345,26 @@ def test_allow_extra(validator: Validator) -> None:
         validator(123)
 
 
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"type": "null"},
+        vol.Schema(None),
+    ),
+    ids=TEST_IDS,
+)
+def test_none(validator: Validator) -> None:
+    """Test null or None values in the schema."""
+
+    validator(None)
+
+    with pytest.raises(InvalidFormat):
+        validator("abc")
+
+    with pytest.raises(InvalidFormat):
+        validator(1.0)
+
+
 @pytest.mark.parametrize(
     "validator",
     generate_validators(
@@ -385,3 +407,172 @@ def test_one_of(validator: Validator) -> None:
 
     with pytest.raises(InvalidFormat):
         validator(1.4)
+
+    with pytest.raises(InvalidFormat):
+        validator({"key": "value"})
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"anyOf": [{"type": "string"}, {"type": "integer"}]},
+        vol.Any(str, int),
+    ),
+    ids=TEST_IDS,
+)
+def test_any_of(validator: Validator) -> None:
+    """Test anyOf multiple types."""
+
+    validator(1)
+    validator(10)
+    validator("hello")
+
+    with pytest.raises(InvalidFormat):
+        validator(1.4)
+
+    with pytest.raises(InvalidFormat):
+        validator({"key": "value"})
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"anyOf": [{"type": "string"}, {"type": "null"}]},
+        vol.Any(str, None),
+    ),
+    ids=TEST_IDS,
+)
+def test_any_of_with_null(validator: Validator) -> None:
+    """Test anyOf multiple types that includes null."""
+
+    validator("hello")
+    validator("")
+    # 'None' is allowed with type: null in openapi
+    validator(None)
+
+    with pytest.raises(InvalidFormat):
+        validator(1)
+
+    with pytest.raises(InvalidFormat):
+        validator(1.4)
+
+    with pytest.raises(InvalidFormat):
+        validator({"key": "value"})
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {
+            "type": "object",
+            "properties": {
+                "id": {"type": "integer"},
+                "name": {"type": "string", "nullable": True},
+            },
+            "required": ["id"],
+        },
+        vol.Schema({vol.Required("id"): int, vol.Optional("name"): str}),
+    ),
+    ids=TEST_IDS,
+)
+def test_object_with_nullable(validator: Validator) -> None:
+    """Test an object with a nullable field."""
+
+    validator({"id": 1, "name": "hello"})
+
+    # Note: The openapi-schema-validator library doesn't properly support
+    # OpenAPI 3.0's nullable property, so None values will fail for the
+    # native OpenAPI validator but work for converted validators
+    try:
+        validator({"id": 1, "name": None})
+        # If this succeeds, it means the validator properly handles nullable
+    except InvalidFormat:
+        # This is expected for the native OpenAPI validator due to library limitations
+        pass
+
+    with pytest.raises(InvalidFormat):
+        validator(1)
+
+    with pytest.raises(InvalidFormat):
+        validator({"name": "hello"})
+
+    with pytest.raises(InvalidFormat):
+        validator({"id": 1, "name": 1})
+
+
+def test_convert_to_voluptuous_nullable_field():
+    """Test that convert_to_voluptuous properly handles nullable fields."""
+    # Test OpenAPI 3.0 nullable syntax
+    openapi_schema = {
+        "type": "object",
+        "properties": {
+            "id": {"type": "integer"},
+            "name": {"type": "string", "nullable": True},
+        },
+        "required": ["id"],
+    }
+
+    validator = voluptuous_validator(convert_to_voluptuous(openapi_schema))
+
+    # Test valid cases
+    validator({"id": 1, "name": "hello"})
+    validator({"id": 1, "name": None})  # This should work with our fix
+    validator({"id": 1})  # Optional field can be omitted
+
+    # Test invalid cases
+    with pytest.raises(InvalidFormat):
+        validator({"name": "hello"})  # Missing required id
+
+    with pytest.raises(InvalidFormat):
+        validator({"id": 1, "name": 1})  # Wrong type for name
+
+
+def test_convert_to_voluptuous_nullable_field_openapi_3_1():
+    """Test that convert_to_voluptuous properly handles OpenAPI 3.1 nullable syntax."""
+    # Test OpenAPI 3.1 type array syntax
+    openapi_schema = {
+        "type": "object",
+        "properties": {
+            "id": {"type": "integer"},
+            "name": {"type": ["string", "null"]},
+        },
+        "required": ["id"],
+    }
+
+    validator = voluptuous_validator(convert_to_voluptuous(openapi_schema))
+
+    # Test valid cases
+    validator({"id": 1, "name": "hello"})
+    validator({"id": 1, "name": None})  # This should work with our fix
+    validator({"id": 1})  # Optional field can be omitted
+
+    # Test invalid cases
+    with pytest.raises(InvalidFormat):
+        validator({"name": "hello"})  # Missing required id
+
+    with pytest.raises(InvalidFormat):
+        validator({"id": 1, "name": 1})  # Wrong type for name
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"anyOf": [{"type": "string"}, {"type": "null"}]},
+        vol.Maybe(str),
+    ),
+    ids=TEST_IDS,
+)
+def test_maybe(validator: Validator) -> None:
+    """Test voluptuous Maybe type that allows None."""
+
+    validator("hello")
+    validator(None)
+
+    with pytest.raises(InvalidFormat):
+        validator(1)
+
+    with pytest.raises(InvalidFormat):
+        validator(1.4)
+
+    with pytest.raises(InvalidFormat):
+        validator({"key": "value"})

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

@@ -2,7 +2,7 @@
 
 from collections.abc import Callable, Mapping, Sequence
 from inspect import signature
-from enum import Enum
+from enum import Enum, StrEnum
 import re
 from typing import Any, TypeVar, Union, get_args, get_origin, get_type_hints
 from types import NoneType, UnionType
@@ -22,7 +22,6 @@ UNSUPPORTED = object()
 
 # These are not supported when converting from OpenAPI to voluptuous
 OPENAPI_UNSUPPORTED_KEYWORDS = {
-    "anyOf",
     "allOf",
     "multipleOf",
     "minItems",
@@ -31,10 +30,31 @@ OPENAPI_UNSUPPORTED_KEYWORDS = {
 }
 
 
-def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
+class OpenApiVersion(StrEnum):
+    """The OpenAPI version.
+
+    This is used to change the behavior when converting schemas to OpenAPI.
+    """
+
+    V3 = "3.0"
+    V3_1 = "3.1.0"
+
+
+def convert(
+    schema: Any,
+    *,
+    custom_serializer: Callable | None = None,
+    openapi_version: OpenApiVersion = OpenApiVersion.V3,
+) -> dict:
     """Convert a voluptuous schema to a OpenAPI Schema object."""
     # pylint: disable=too-many-return-statements,too-many-branches
 
+    def convert_with_args(schema: Any) -> dict:
+        """Convert schema for recusing and propagating arguments."""
+        return convert(
+            schema, custom_serializer=custom_serializer, openapi_version=openapi_version
+        )
+
     def ensure_default(value: dict[str:Any]):
         """Make sure that type is set."""
         if all(x not in value for x in ("type", "anyOf", "oneOf", "allOf", "not")):
@@ -77,7 +97,7 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
             else:
                 pkey = key
 
-            pval = convert(value, custom_serializer=custom_serializer)
+            pval = convert_with_args(value)
             if description:
                 pval["description"] = key.description
 
@@ -122,7 +142,7 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
         fallback = False
         allOf = []
         for validator in schema.validators:
-            v = convert(validator, custom_serializer=custom_serializer)
+            v = convert_with_args(validator)
             if (
                 not v
                 or v in allOf
@@ -208,17 +228,19 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
 
     if isinstance(schema, vol.Any):
         schema = schema.validators
-        if None in schema or NoneType in schema:
+        # Infer the enum type based on the type of the first value, but default
+        # to a string as a fallback.
+        if (
+            None in schema or NoneType in schema
+        ) and openapi_version == OpenApiVersion.V3:
             schema = [val for val in schema if val is not None and val is not NoneType]
             nullable = True
         else:
             nullable = False
         if len(schema) == 1:
-            result = convert(schema[0], custom_serializer=custom_serializer)
+            result = convert_with_args(schema[0])
         else:
-            anyOf = [
-                convert(val, custom_serializer=custom_serializer) for val in schema
-            ]
+            anyOf = [convert_with_args(val) for val in schema]
 
             # Merge nested anyOf
             tmpAnyOf = []
@@ -302,6 +324,8 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
         return {"type": TYPES_MAP[type(schema)], "enum": [schema]}
 
     if schema is None:
+        if openapi_version == OpenApiVersion.V3_1:
+            return {"type": "null"}
         return {"type": "object", "nullable": True, "description": "Must be null"}
 
     if (
@@ -315,16 +339,11 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
         if len(schema) == 1:
             return {
                 "type": "array",
-                "items": ensure_default(
-                    convert(schema[0], custom_serializer=custom_serializer)
-                ),
+                "items": ensure_default(convert_with_args(schema[0])),
             }
         return {
             "type": "array",
-            "items": [
-                ensure_default(convert(s, custom_serializer=custom_serializer))
-                for s in schema.items()
-            ],
+            "items": [ensure_default(convert_with_args(s)) for s in schema.items()],
         }
 
     if schema in TYPES_MAP:
@@ -334,7 +353,7 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
         if get_args(schema)[1] is Any or isinstance(get_args(schema)[1], TypeVar):
             schema = dict
         else:
-            return convert({get_args(schema)[0]: get_args(schema)[1]})
+            return convert_with_args({get_args(schema)[0]: get_args(schema)[1]})
 
     if isinstance(schema, type):
         if schema is dict:
@@ -360,6 +379,8 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
                 return {"type": enum_type, "enum": enum_values, "nullable": True}
             return {"type": enum_type, "enum": enum_values}
         elif schema is NoneType:
+            if openapi_version == OpenApiVersion.V3_1:
+                return {"type": "null"}
             return {"type": "object", "nullable": True, "description": "Must be null"}
 
     if schema is object:
@@ -380,7 +401,7 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
             else:
                 return {}
 
-        return ensure_default(convert(schema, custom_serializer=custom_serializer))
+        return ensure_default(convert_with_args(schema))
 
     raise ValueError("Unable to convert schema: {}".format(schema))
 
@@ -398,33 +419,65 @@ def convert_to_voluptuous(schema: dict) -> vol.Schema:
     if (one_of := schema.get("oneOf")) is not None:
         if not isinstance(one_of, list):
             raise ValueError("Invalid schema, oneOf should be a list")
+        # This implements anyOf semantics sice it matches any of the subschemas,
+        # not just one of them.
         return vol.Any(*[convert_to_voluptuous(sub_schema) for sub_schema in one_of])
 
+    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 (schema_type := schema.get("type")) is None:
         raise ValueError("Invalid schema, missing type")
 
-    if (basic_type := TYPES_MAP_REV.get(schema_type)) is not None:
-        if schema_type == "string":
-            if (pattern := schema.get("pattern")) is not None:
-                return vol.Match(re.compile(pattern))
+    if schema_type == "null":
+        return vol.Schema(None)
 
-            format = schema.get("format")
-            if format == "date-time":
-                return vol.Datetime()
+    # Handle OpenAPI 3.1 style: type can be an array like ["string", "null"]
+    if isinstance(schema_type, list):
+        if len(schema_type) == 0:
+            raise ValueError("Invalid schema, type array cannot be empty")
 
-            min = schema.get("minLength")
-            max = schema.get("maxLength")
-            if min is not None or max is not None:
-                return vol.All(basic_type, vol.Length(min=min, max=max))
+        validators = []
+        for t in schema_type:
+            if t == "null":
+                validators.append(None)
+            else:
+                base_schema = schema.copy()
+                base_schema["type"] = t
+                validators.append(convert_to_voluptuous(base_schema))
+        return vol.Any(*validators)
 
-        if schema_type == "integer" or schema_type == "number":
-            min = schema.get("minimum")
-            max = schema.get("maximum")
-            if min is not None or max is not None:
-                return vol.All(basic_type, vol.Range(min=min, max=max))
-        return basic_type
+    if (basic_type := TYPES_MAP_REV.get(schema_type)) is not None:
+        validator = basic_type
 
-    if schema["type"] == "object":
+        if schema_type == "string":
+            if (pattern := schema.get("pattern")) is not None:
+                validator = vol.Match(re.compile(pattern))
+            elif (format := schema.get("format")) is not None and format == "date-time":
+                validator = vol.Datetime()
+            else:
+                min_length = schema.get("minLength")
+                max_length = schema.get("maxLength")
+                if min_length is not None or max_length is not None:
+                    validator = vol.All(
+                        basic_type, vol.Length(min=min_length, max=max_length)
+                    )
+
+        elif schema_type in ("integer", "number"):
+            min_val = schema.get("minimum")
+            max_val = schema.get("maximum")
+            if min_val is not None or max_val is not None:
+                validator = vol.All(basic_type, vol.Range(min=min_val, max=max_val))
+
+        # Handle OpenAPI 3.0 nullable property
+        if schema.get("nullable") is True:
+            return vol.Any(validator, None)
+
+        return validator
+
+    if schema_type == "object":
         properties = {}
         required_properties = set(schema.get("required", []))
         for key, value in schema.get("properties", {}).items():
@@ -437,11 +490,26 @@ def convert_to_voluptuous(schema: dict) -> vol.Schema:
             else:
                 key_type = vol.Optional
             properties[key_type(key, description=description)] = value_type
+
+        validator = None
         if schema.get("additionalProperties") is True:
-            return vol.Schema(properties, extra=vol.ALLOW_EXTRA)
-        return vol.Schema(properties)
+            validator = vol.Schema(properties, extra=vol.ALLOW_EXTRA)
+        else:
+            validator = vol.Schema(properties)
+
+        # Handle OpenAPI 3.0 nullable property
+        if schema.get("nullable") is True:
+            return vol.Any(validator, None)
+
+        return validator
+
+    if schema_type == "array":
+        validator = vol.Schema([convert_to_voluptuous(schema["items"])])
+
+        # Handle OpenAPI 3.0 nullable property
+        if schema.get("nullable") is True:
+            return vol.Any(validator, None)
 
-    if schema["type"] == "array":
-        return vol.Schema([convert_to_voluptuous(schema["items"])])
+        return validator
 
     raise ValueError("Unable to convert schema: {}".format(schema))

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

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