1. import json
  3. def validate_json(json_data, schema):
  4. """
  5. Validates a JSON object against a given schema.
  7. Args:
  8. json_data (dict): The JSON object to validate.
  9. schema (dict): The schema to validate against.
  11. Returns:
  12. list: A list of flagged anomalies (error messages). Empty list if valid.
  13. """
  14. anomalies = []
  16. def check_type(value, expected_type):
  17. """Checks if a value matches the expected type."""
  18. if type(value) != expected_type:
  19. return f"Type mismatch: Expected {expected_type}, got {type(value)}"
  20. return None
  22. def check_required_fields(data, schema):
  23. """Checks for missing required fields."""
  24. for key, value in schema.items():
  25. if key not in data:
  26. return f"Missing required field: {key}"
  27. return None
  29. def check_value_constraints(value, constraints):
  30. """Checks if a value meets specific constraints."""
  31. if constraints:
  32. for constraint_type, constraint_value in constraints.items():
  33. if constraint_type == "min":
  34. if not isinstance(value, (int, float)) or value < constraint_value:
  35. return f"Value {key} must be >= {constraint_value}"
  36. elif constraint_type == "max":
  37. if not isinstance(value, (int, float)) or value > constraint_value:
  38. return f"Value {key} must be <= {constraint_value}"
  39. elif constraint_type == "in":
  40. if value not in constraint_value:
  41. return f"Value {key} must be one of: {constraint_value}"
  42. return None
  44. # Check required fields
  45. required_error = check_required_fields(json_data, schema)
  46. if required_error:
  47. anomalies.append(required_error)
  49. # Check data types
  50. for key, value in schema.items():
  51. if key in json_data:
  52. if isinstance(value, dict):
  53. if not isinstance(json_data[key], dict):
  54. anomalies.append(f"Type mismatch for {key}: Expected dict, got {type(json_data[key])}")
  55. continue
  56. else:
  57. nested_errors = validate_json(json_data[key], value)
  58. anomalies.extend(nested_errors)
  59. elif isinstance(value, list):
  60. if not isinstance(json_data[key], list):
  61. anomalies.append(f"Type mismatch for {key}: Expected list, got {type(json_data[key])}")
  62. continue
  63. else:
  64. for i, item in enumerate(json_data[key]):
  65. if isinstance(value[i], dict):
  66. if not isinstance(item, dict):
  67. anomalies.append(f"Type mismatch for item in list {key} at index {i}: Expected dict, got {type(item)}")
  68. elif isinstance(value[i], list):
  69. anomalies.append(f"Type mismatch for item in list {key} at index {i}: Expected list, got {type(item)}")
  70. else:
  71. continue #ignore simple types
  72. else:
  73. error = check_type(json_data[key], value)
  74. if error:
  75. anomalies.append(error)
  77. return anomalies
  80. if __name__ == '__main__':
  81. # Example Usage
  82. schema = {
  83. "name": str,
  84. "age": int,
  85. "city": str,
  86. "scores": list,
  87. "details": {
  88. "height": float,
  89. "weight": float
  90. }
  91. }
  93. valid_json = {
  94. "name": "Alice",
  95. "age": 30,
  96. "city": "New York",
  97. "scores": [85, 90, 92],
  98. "details": {
  99. "height": 1.75,
  100. "weight": 60.0
  101. }
  102. }
  104. invalid_json = {
  105. "name": 123,
  106. "age": "thirty",
  107. "scores": "not a list",
  108. "details": {
  109. "height": "tall",
  110. "weight": -10.0
  111. }
  112. }
  114. print("

Add your comment