reformatted

Author: doubledare704

examples/json_schema_export.py

@@ -13,26 +13,42 @@
 """
 
 import json
+
 from voluptuous import (
-    Schema, Required, Optional, All, Any, Range, Length, In, Match, 
-    Email, Url, Date, Datetime, Coerce, Clamp, ExactSequence, to_json_schema
+    All,
+    Any,
+    Clamp,
+    Coerce,
+    Date,
+    Datetime,
+    Email,
+    ExactSequence,
+    In,
+    Length,
+    Match,
+    Optional,
+    Range,
+    Required,
+    Schema,
+    Url,
+    to_json_schema,
 )
 
 
 def example_basic_types():
     """Demonstrate basic type conversion."""
     print("=== Basic Types ===")
-    
+
     # Simple types
     schemas = {
         "String": Schema(str),
         "Integer": Schema(int),
         "Float": Schema(float),
         "Boolean": Schema(bool),
         "Literal": Schema("hello"),
-        "None": Schema(None)
+        "None": Schema(None),
     }
-    
+
     for name, schema in schemas.items():
         json_schema = schema.to_json_schema()
         print(f"{name}: {json.dumps(json_schema, indent=2)}")
@@ -42,20 +58,22 @@ def example_basic_types():
 def example_object_schemas():
     """Demonstrate object schema conversion."""
     print("=== Object Schemas ===")
-    
+
     # User profile schema
-    user_schema = Schema({
-        Required('username'): All(str, Length(min=3, max=20)),
-        Required('email'): Email(),
-        Optional('age'): Range(min=13, max=120),
-        Optional('bio', default=""): All(str, Length(max=500)),
-        Optional('preferences'): {
-            'theme': In(['light', 'dark', 'auto']),
-            'notifications': bool,
-            'language': str
+    user_schema = Schema(
+        {
+            Required('username'): All(str, Length(min=3, max=20)),
+            Required('email'): Email(),
+            Optional('age'): Range(min=13, max=120),
+            Optional('bio', default=""): All(str, Length(max=500)),
+            Optional('preferences'): {
+                'theme': In(['light', 'dark', 'auto']),
+                'notifications': bool,
+                'language': str,
+            },
         }
-    })
-    
+    )
+
     json_schema = user_schema.to_json_schema()
     print("User Profile Schema:")
     print(json.dumps(json_schema, indent=2))
@@ -65,19 +83,19 @@ def example_object_schemas():
 def example_array_schemas():
     """Demonstrate array schema conversion."""
     print("=== Array Schemas ===")
-    
+
     # Simple array
     simple_array = Schema([str])
     print("Simple String Array:")
     print(json.dumps(simple_array.to_json_schema(), indent=2))
     print()
-    
+
     # Mixed array with exact sequence
     exact_sequence = Schema(ExactSequence([str, int, bool]))
     print("Exact Sequence [str, int, bool]:")
     print(json.dumps(exact_sequence.to_json_schema(), indent=2))
     print()
-    
+
     # Set (unique items)
     unique_strings = Schema({str})
     print("Set of Strings (unique items):")
@@ -88,7 +106,7 @@ def example_array_schemas():
 def example_validators():
     """Demonstrate validator conversion."""
     print("=== Validators ===")
-    
+
     validators = {
         "Range": Schema(Range(min=1, max=100)),
         "Length": Schema(All(str, Length(min=2, max=50))),
@@ -98,9 +116,9 @@ def example_validators():
         "DateTime": Schema(Datetime()),
         "Pattern": Schema(Match(r'^[A-Z][a-z]+$')),
         "Enum": Schema(In(['red', 'green', 'blue'])),
-        "Coerce": Schema(Coerce(int))
+        "Coerce": Schema(Coerce(int)),
     }
-    
+
     for name, schema in validators.items():
         json_schema = schema.to_json_schema()
         print(f"{name}:")
@@ -111,13 +129,13 @@ def example_validators():
 def example_composite_validators():
     """Demonstrate composite validator conversion."""
     print("=== Composite Validators ===")
-    
+
     # All validator (must pass all conditions)
     all_validator = Schema(All(str, Length(min=1), Match(r'^[a-zA-Z]+$')))
     print("All(str, Length(min=1), Match('^[a-zA-Z]+$')):")
     print(json.dumps(all_validator.to_json_schema(), indent=2))
     print()
-    
+
     # Any validator (must pass at least one condition)
     any_validator = Schema(Any(str, int, bool))
     print("Any(str, int, bool):")
@@ -128,37 +146,41 @@ def example_composite_validators():
 def example_complex_schema():
     """Demonstrate a complex, real-world schema."""
     print("=== Complex Real-World Schema ===")
-    
+
     # API configuration schema
-    api_config_schema = Schema({
-        Required('api'): {
-            Required('name'): All(str, Length(min=1, max=100)),
-            Required('version'): Match(r'^\d+\.\d+\.\d+$'),
-            Required('endpoints'): [{
-                Required('path'): All(str, Match(r'^/[a-zA-Z0-9/_-]*$')),
-                Required('method'): In(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']),
-                Optional('auth_required', default=True): bool,
-                Optional('rate_limit'): Range(min=1, max=10000),
-                Optional('description'): All(str, Length(max=500))
-            }],
-            Optional('database'): {
-                Required('host'): str,
-                Required('port'): Range(min=1, max=65535),
-                Required('name'): All(str, Length(min=1, max=64)),
-                Optional('ssl', default=True): bool,
-                Optional('timeout', default=30): Range(min=1, max=300)
-            }
-        },
-        Optional('logging'): {
-            'level': In(['DEBUG', 'INFO', 'WARNING', 'ERROR']),
-            'format': str,
-            'file': str
-        },
-        Optional('features'): {
-            str: bool  # Feature flags
+    api_config_schema = Schema(
+        {
+            Required('api'): {
+                Required('name'): All(str, Length(min=1, max=100)),
+                Required('version'): Match(r'^\d+\.\d+\.\d+$'),
+                Required('endpoints'): [
+                    {
+                        Required('path'): All(str, Match(r'^/[a-zA-Z0-9/_-]*$')),
+                        Required('method'): In(
+                            ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']
+                        ),
+                        Optional('auth_required', default=True): bool,
+                        Optional('rate_limit'): Range(min=1, max=10000),
+                        Optional('description'): All(str, Length(max=500)),
+                    }
+                ],
+                Optional('database'): {
+                    Required('host'): str,
+                    Required('port'): Range(min=1, max=65535),
+                    Required('name'): All(str, Length(min=1, max=64)),
+                    Optional('ssl', default=True): bool,
+                    Optional('timeout', default=30): Range(min=1, max=300),
+                },
+            },
+            Optional('logging'): {
+                'level': In(['DEBUG', 'INFO', 'WARNING', 'ERROR']),
+                'format': str,
+                'file': str,
+            },
+            Optional('features'): {str: bool},  # Feature flags
         }
-    })
-    
+    )
+
     json_schema = api_config_schema.to_json_schema()
     print("API Configuration Schema:")
     print(json.dumps(json_schema, indent=2))
@@ -168,38 +190,40 @@ def example_complex_schema():
 def example_usage_with_data():
     """Show how the exported schema can validate actual data."""
     print("=== Usage Example ===")
-    
+
     # Define a schema
-    person_schema = Schema({
-        Required('name'): All(str, Length(min=1, max=100)),
-        Required('email'): Email(),
-        Optional('age'): Range(min=0, max=150),
-        Optional('tags'): [str]
-    })
-    
+    person_schema = Schema(
+        {
+            Required('name'): All(str, Length(min=1, max=100)),
+            Required('email'): Email(),
+            Optional('age'): Range(min=0, max=150),
+            Optional('tags'): [str],
+        }
+    )
+
     # Export to JSON Schema
     json_schema = person_schema.to_json_schema()
-    
+
     # Sample data that would be valid
     sample_data = {
         "name": "John Doe",
         "email": "john@example.com",
         "age": 30,
-        "tags": ["developer", "python"]
+        "tags": ["developer", "python"],
     }
-    
+
     print("Voluptuous Schema:")
     print(f"Schema: {person_schema}")
     print()
-    
+
     print("Exported JSON Schema:")
     print(json.dumps(json_schema, indent=2))
     print()
-    
+
     print("Sample Valid Data:")
     print(json.dumps(sample_data, indent=2))
     print()
-    
+
     # Validate with voluptuous
     try:
         validated = person_schema(sample_data)
@@ -214,15 +238,15 @@ def main():
     print("Voluptuous JSON Schema Export Examples")
     print("=" * 50)
     print()
-    
+
     example_basic_types()
     example_object_schemas()
     example_array_schemas()
     example_validators()
     example_composite_validators()
     example_complex_schema()
     example_usage_with_data()
-    
+
     print("=" * 50)
     print("Examples completed!")
     print()

voluptuous/__init__.py

@@ -74,12 +74,13 @@
     True
 """
 
+from voluptuous.json_schema import to_json_schema
+
 # flake8: noqa
 # fmt: off
 from voluptuous.schema_builder import *
 from voluptuous.util import *
 from voluptuous.validators import *
-from voluptuous.json_schema import to_json_schema
 
 from voluptuous.error import *  # isort: skip