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

{voluptuous_openapi-0.0.2/voluptuous_openapi.egg-info → voluptuous_openapi-0.0.3}/PKG-INFO

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

{voluptuous_openapi-0.0.2 → voluptuous_openapi-0.0.3}/setup.py

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

{voluptuous_openapi-0.0.2 → voluptuous_openapi-0.0.3}/tests/test_lib.py

@@ -91,6 +91,33 @@ def test_dict():
         )
     )
 
+    assert {"type": "object", "additionalProperties": True} == convert(vol.Schema(dict))
+
+    assert {"type": "object", "additionalProperties": True} == convert(
+        vol.Schema(dict[str, Any])
+    )
+
+    assert {"type": "object", "additionalProperties": {"type": "integer"}} == convert(
+        vol.Schema({str: int})
+    )
+
+    assert {
+        "type": "object",
+        "properties": {"x": {"type": "integer"}},
+        "required": [],
+        "additionalProperties": {"type": "string"},
+    } == convert(vol.Schema({"x": int, str: str}))
+
+
+def test_tuple():
+    assert {"type": "array", "items": {"type": "string"}} == convert(vol.Schema(tuple))
+    assert {"type": "array", "items": {"type": "string"}} == convert(
+        vol.Schema(tuple[Any])
+    )
+    assert {"type": "array", "items": {"type": "integer"}} == convert(
+        vol.Schema(tuple[int])
+    )
+
 
 def test_marker_description():
     assert {
@@ -211,6 +238,14 @@ def test_list():
 
     assert {"type": "array", "items": {"type": "string"}} == convert(vol.Schema(list))
 
+    assert {"type": "array", "items": {"type": "string"}} == convert(
+        vol.Schema(list[Any])
+    )
+
+    assert {"type": "array", "items": {"type": "integer"}} == convert(
+        vol.Schema(list[int])
+    )
+
 
 def test_any_of():
     assert {"anyOf": [{"type": "number"}, {"type": "integer"}]} == convert(
@@ -230,15 +265,22 @@ def test_key_any():
         "properties": {
             "name": {
                 "type": "string",
-                "description": "At least one of ('name', 'area') must be provided",
             },
             "area": {
                 "type": "string",
-                "description": "At least one of ('name', 'area') must be provided",
+                "description": "The ID or the area",
             },
         },
         "required": [],
-    } == convert(vol.Schema({vol.Any("name", "area"): str}))
+    } == convert(
+        vol.Schema(
+            {
+                vol.Any(
+                    "name", vol.Optional("area", description="The ID or the area")
+                ): str
+            }
+        )
+    )
 
 
 def test_function():

{voluptuous_openapi-0.0.2 → voluptuous_openapi-0.0.3}/voluptuous_openapi/__init__.py

@@ -53,22 +53,6 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
         properties = {}
         required = []
 
-        # Unfold vol.Any in keys
-        if vol.Any in [type(k) for k in schema.keys()]:
-            pschema = {}
-            for key, value in schema.items():
-                if isinstance(key, vol.Any):
-                    description = key.msg
-                    if not description:
-                        description = (
-                            f"At least one of {key.validators} must be provided"
-                        )
-                    for val in key.validators:
-                        pschema[vol.Optional(val, description=description)] = value
-                else:
-                    pschema[key] = value
-            schema = pschema
-
         for key, value in schema.items():
             description = None
             if isinstance(key, vol.Marker):
@@ -86,13 +70,30 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
                     pval["default"] = key.default()
 
             pval = ensure_default(pval)
-            pkey = str(pkey)
-            properties[pkey] = pval
+
+            if isinstance(pkey, type) and issubclass(pkey, str):
+                if additional_properties is None:
+                    additional_properties = pval
+            elif isinstance(key, vol.Any):
+                for val in key.validators:
+                    if isinstance(val, vol.Marker):
+                        if val.description:
+                            properties[str(val.schema)] = pval.copy()
+                            properties[str(val.schema)]["description"] = val.description
+                        else:
+                            properties[str(val)] = pval
+                    else:
+                        properties[str(val)] = pval
+            else:
+                properties[str(pkey)] = pval
 
             if isinstance(key, vol.Required):
-                required.append(pkey)
+                required.append(str(pkey))
 
-        val = {"type": "object", "properties": properties, "required": required}
+        val = {"type": "object"}
+        if properties:
+            val["properties"] = properties
+            val["required"] = required
         if additional_properties:
             val["additionalProperties"] = additional_properties
         return val
@@ -186,6 +187,13 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
     if isinstance(schema, (str, int, float, bool)) or schema is None:
         return {"enum": [schema]}
 
+    if (
+        get_origin(schema) is list
+        or get_origin(schema) is set
+        or get_origin(schema) is tuple
+    ):
+        schema = [get_args(schema)[0]]
+
     if isinstance(schema, Sequence):
         if len(schema) == 1:
             return {
@@ -205,13 +213,19 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
     if schema in TYPES_MAP:
         return {"type": TYPES_MAP[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 get_origin(schema) is 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]})
 
     if isinstance(schema, type):
+        if schema is dict:
+            return {"type": "object", "additionalProperties": True}
+
+        if schema is list or schema is set or schema is tuple:
+            return {"type": "array", "items": ensure_default({})}
+
         if issubclass(schema, Enum):
             return {"enum": [item.value for item in schema]}
         elif schema is NoneType:
@@ -231,19 +245,6 @@ def convert(schema: Any, *, custom_serializer: Callable | None = None) -> dict:
                 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)
 

{voluptuous_openapi-0.0.2 → voluptuous_openapi-0.0.3/voluptuous_openapi.egg-info}/PKG-INFO

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