voluptuous-openapi 0.0.1__tar.gz → 0.0.2__tar.gz

{voluptuous-openapi-0.0.1/voluptuous_openapi.egg-info → voluptuous_openapi-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: voluptuous-openapi
-Version: 0.0.1
+Version: 0.0.2
 Summary: Convert voluptuous schemas to OpenAPI Schema object
 Home-page: http://github.com/Shulyaka/voluptuous-openapi
 Author: Denis Shulyaka

{voluptuous-openapi-0.0.1 → voluptuous_openapi-0.0.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup
 
 setup(
     name="voluptuous-openapi",
-    version="0.0.1",
+    version="0.0.2",
     description="Convert voluptuous schemas to OpenAPI Schema object",
     url="http://github.com/Shulyaka/voluptuous-openapi",
     author="Denis Shulyaka",

{voluptuous-openapi-0.0.1 → voluptuous_openapi-0.0.2}/tests/test_lib.py

@@ -1,6 +1,7 @@
 from enum import Enum
 
 import voluptuous as vol
+from typing import Any, TypeVar
 
 from voluptuous_openapi import UNSUPPORTED, convert
 
@@ -191,6 +192,7 @@ def test_custom_serializer():
 def test_constant():
     for value in True, False, "Hello", 1, None:
         assert {"enum": [value]} == convert(vol.Schema(value))
+    assert {"enum": [None]} == convert(vol.Schema(type(None)))
 
 
 def test_enum():
@@ -207,6 +209,20 @@ def test_list():
         "items": {"type": "string"},
     } == convert(vol.Schema([str]))
 
+    assert {"type": "array", "items": {"type": "string"}} == convert(vol.Schema(list))
+
+
+def test_any_of():
+    assert {"anyOf": [{"type": "number"}, {"type": "integer"}]} == convert(
+        vol.Any(float, int)
+    )
+
+
+def test_all_of():
+    assert {"allOf": [{"minimum": 5}, {"minimum": 10}]} == convert(
+        vol.All(vol.Range(min=5), vol.Range(min=10))
+    )
+
 
 def test_key_any():
     assert {
@@ -223,3 +239,94 @@ def test_key_any():
         },
         "required": [],
     } == convert(vol.Schema({vol.Any("name", "area"): str}))
+
+
+def test_function():
+    def validator(data):
+        return data
+
+    assert {
+        "type": "object",
+        "properties": {"test_data": {"type": "string"}},
+        "required": [],
+    } == convert(vol.Schema({"test_data": validator}))
+
+    def validator_str(data: str):
+        return data
+
+    assert {"type": "string"} == convert(vol.Schema(validator_str))
+
+    def validator_any(data: Any):
+        return data
+
+    assert {} == convert(validator_any)
+    assert {"type": "integer"} == convert(vol.All(vol.Coerce(int), lambda x: x / 100))
+
+    def validator_nullable(data: float | None):
+        return data
+
+    assert {"type": "number", "nullable": True} == convert(
+        vol.Schema(validator_nullable)
+    )
+
+    def validator_union(data: float | int):
+        return data
+
+    assert {"anyOf": [{"type": "number"}, {"type": "integer"}]} == convert(
+        vol.Schema(validator_union)
+    )
+
+    _T = TypeVar("_T")
+
+    def validator_nullable_2(value: _T | None):
+        return value
+
+    assert {
+        "type": "object",
+        "properties": {"var": {"type": "array", "items": {"type": "string"}}},
+        "required": [],
+    } == convert(vol.Schema({"var": vol.All(validator_nullable_2, [validator_any])}))
+
+    def validator_list_int(value: list[int]):
+        return value
+
+    assert {"type": "array", "items": {"type": "integer"}} == convert(
+        validator_list_int
+    )
+
+    def validator_list_any(value: list[Any]):
+        return value
+
+    assert {"type": "array", "items": {"type": "string"}} == convert(validator_list_any)
+
+    def validator_list(value: list):
+        return value
+
+    assert {"type": "array", "items": {"type": "string"}} == convert(validator_list)
+
+    def validator_set_int(value: set[int]):
+        return value
+
+    assert {"type": "array", "items": {"type": "integer"}} == convert(validator_set_int)
+
+    def validator_set_any(value: set[Any]):
+        return value
+
+    assert {"type": "array", "items": {"type": "string"}} == convert(validator_set_any)
+
+    def validator_set(value: set):
+        return value
+
+    assert {"type": "array", "items": {"type": "string"}} == convert(validator_set)
+
+    def validator_dict(value: dict):
+        return value
+
+    assert {"type": "object", "additionalProperties": True} == convert(validator_dict)
+
+    def validator_dict_int(value: dict[str, int]):
+        return value
+
+    assert {"type": "object", "additionalProperties": {"type": "integer"}} == convert(
+        validator_dict_int
+    )

{voluptuous-openapi-0.0.1 → voluptuous_openapi-0.0.2}/voluptuous_openapi/__init__.py

@@ -2,7 +2,9 @@
 
 from collections.abc import Callable, Mapping, Sequence
 from enum import Enum
-from typing import Any
+from typing import Any, TypeVar, Union, get_args, get_origin, get_type_hints
+from types import NoneType, UnionType
+from inspect import signature
 
 import voluptuous as vol
 
@@ -20,6 +22,15 @@ UNSUPPORTED = object()
 def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
     """Convert a voluptuous schema to a OpenAPI Schema object."""
     # pylint: disable=too-many-return-statements,too-many-branches
+
+    def ensure_default(value: dict[str:Any]):
+        """Make sure that type is set."""
+        if all(
+            x not in value for x in ("type", "enum", "anyOf", "oneOf", "allOf", "not")
+        ):
+            value["type"] = "string"  # Type not determined, using default
+        return value
+
     additional_properties = None
     if isinstance(schema, vol.Schema):
         if schema.extra == vol.ALLOW_EXTRA:
@@ -31,6 +42,13 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
         if val is not UNSUPPORTED:
             return val
 
+    if isinstance(schema, vol.Object):
+        schema = schema.schema
+        if custom_serializer:
+            val = custom_serializer(schema)
+            if val is not UNSUPPORTED:
+                return val
+
     if isinstance(schema, Mapping):
         properties = {}
         required = []
@@ -67,6 +85,7 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
                 if key.default is not vol.UNDEFINED:
                     pval["default"] = key.default()
 
+            pval = ensure_default(pval)
             pkey = str(pkey)
             properties[pkey] = pval
 
@@ -94,7 +113,7 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
                 val.update(v)
         if fallback:
             return {"allOf": allOf}
-        return val
+        return ensure_default(val)
 
     if isinstance(schema, (vol.Clamp, vol.Range)):
         val = {}
@@ -143,18 +162,23 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
         }
 
     if isinstance(schema, vol.Any):
-        # vol.Maybe
-        if len(schema.validators) == 2 and schema.validators[0] is None:
-            result = convert(schema.validators[1], custom_serializer=custom_serializer)
+        schema = schema.validators
+        if None in schema or NoneType in schema:
+            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)
+        else:
+            result = {
+                "anyOf": [
+                    convert(val, custom_serializer=custom_serializer) for val in schema
+                ]
+            }
+        if nullable:
             result["nullable"] = True
-            return result
-
-        return {
-            "anyOf": [
-                convert(val, custom_serializer=custom_serializer)
-                for val in schema.validators
-            ]
-        }
+        return result
 
     if isinstance(schema, vol.Coerce):
         schema = schema.type
@@ -166,19 +190,61 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
         if len(schema) == 1:
             return {
                 "type": "array",
-                "items": convert(schema[0], custom_serializer=custom_serializer),
+                "items": ensure_default(
+                    convert(schema[0], custom_serializer=custom_serializer)
+                ),
             }
         return {
             "type": "array",
             "items": [
-                convert(s, custom_serializer=custom_serializer) for s in schema.items()
+                ensure_default(convert(s, custom_serializer=custom_serializer))
+                for s in schema.items()
             ],
         }
 
     if schema in TYPES_MAP:
         return {"type": TYPES_MAP[schema]}
 
-    if isinstance(schema, type) and issubclass(schema, Enum):
-        return {"enum": [item.value for item in schema]}
+    if schema is list or schema is set:
+        return {"type": "array", "items": ensure_default({})}
+
+    if schema is dict:
+        return {"type": "object", "additionalProperties": True}
+
+    if isinstance(schema, type):
+        if issubclass(schema, Enum):
+            return {"enum": [item.value for item in schema]}
+        elif schema is NoneType:
+            return {"enum": [None]}
+
+    if callable(schema):
+        schema = get_type_hints(schema).get(
+            list(signature(schema).parameters.keys())[0], Any
+        )
+        if schema is Any or isinstance(schema, TypeVar):
+            return {}
+        if isinstance(schema, UnionType) or get_origin(schema) is Union:
+            schema = [t for t in get_args(schema) if not isinstance(t, TypeVar)]
+            if len(schema) > 1:
+                schema = vol.Any(*schema)
+            elif len(schema) == 1 and schema[0] is not NoneType:
+                schema = schema[0]
+            else:
+                return {}
+        if get_origin(schema) is dict:
+            schema = get_args(schema)[1]
+            if schema is Any or isinstance(schema, TypeVar):
+                schema = dict
+            else:
+                return {
+                    "type": "object",
+                    "additionalProperties": convert(
+                        schema, custom_serializer=custom_serializer
+                    ),
+                }
+        if get_origin(schema) is list or get_origin(schema) is set:
+            schema = [get_args(schema)[0]]
+
+        return convert(schema, custom_serializer=custom_serializer)
 
     raise ValueError("Unable to convert schema: {}".format(schema))

{voluptuous-openapi-0.0.1 → voluptuous_openapi-0.0.2/voluptuous_openapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: voluptuous-openapi
-Version: 0.0.1
+Version: 0.0.2
 Summary: Convert voluptuous schemas to OpenAPI Schema object
 Home-page: http://github.com/Shulyaka/voluptuous-openapi
 Author: Denis Shulyaka