def evaluate(self, instance: JSON, scope: Scope) -> None:
if len(instance) == 0:
return
elif isinstance(self.json.value, bool):
self.json.evaluate(instance, scope)
elif isinstance(self.json, JSONSchema):
for index, item in enumerate(instance):
self.json.evaluate(item, scope)
if scope.valid:
scope.annotate(instance, "items", True)
elif self.json.type == "array":
eval_index = None
err_indices = []
for index, item in enumerate(instance[:len(self.json)]):
eval_index = index
with scope(str(index)) as subscope:
self.json[index].evaluate(item, subscope)
if not subscope.valid:
err_indices += [index]
if err_indices:
scope.fail(instance,
f"Array elements {err_indices} are invalid")
else:
scope.annotate(instance, "items", eval_index)
def evaluate(self, instance: JSON, scope: Scope) -> None:
last_evaluated_item = -1
for items_annotation in scope.parent.collect_annotations(
instance, "items"):
if items_annotation.value is True:
scope.discard()
return
if type(items_annotation.value
) is int and items_annotation.value > last_evaluated_item:
last_evaluated_item = items_annotation.value
for additional_items_annotation in scope.parent.collect_annotations(
instance, "additionalItems"):
if additional_items_annotation.value is True:
scope.discard()
return
for unevaluated_items_annotation in scope.parent.collect_annotations(
instance, "unevaluatedItems"):
if unevaluated_items_annotation.value is True:
scope.discard()
return
annotation = None
for index, item in enumerate(instance[last_evaluated_item + 1:]):
annotation = True
self.json.evaluate(item, scope)
if scope.valid:
scope.annotate(instance, self.key, annotation)
def evaluate(self, instance: JSON, scope: Scope) -> None:
scope.annotate(instance, self.key, self.json.value)
if self.validator is not None:
try:
self.validator(instance.value)
except ValueError as e:
scope.fail(instance, f'The instance is invalid against the "{self.json.value}" format: {e}')
else:
scope.noassert()
def evaluate(self, instance: JSON, scope: Scope) -> None:
if (items := scope.sibling("items")) and \
(items_annotation := items.annotations.get("items")) and \
type(items_annotation.value) is int:
annotation = None
for index, item in enumerate(instance[items_annotation.value +
1:]):
annotation = True
self.json.evaluate(item, scope)
if scope.valid:
scope.annotate(instance, "additionalItems", annotation)
def evaluate(self, instance: JSON, scope: Scope) -> None:
annotation = []
for index, item in enumerate(instance):
if self.json.evaluate(item, scope).valid:
annotation += [index]
else:
scope.errors.clear()
scope.annotate(instance, self.key, annotation)
if not annotation:
scope.fail(
instance,
'The array does not contain any element that is valid '
f'against the "{self.key}" subschema')
def evaluate(self, instance: JSON, scope: Scope) -> None:
annotation = []
err_names = []
for name, item in instance.items():
if name in self.json:
with scope(name) as subscope:
self.json[name].evaluate(item, subscope)
if subscope.valid:
annotation += [name]
else:
err_names += [name]
if err_names:
scope.fail(instance, f"Properties {err_names} are invalid")
else:
scope.annotate(instance, self.key, annotation)
def evaluate(self, instance: JSON, scope: Scope) -> None:
eval_index = None
err_indices = []
for index, item in enumerate(instance[:len(self.json)]):
eval_index = index
with scope(str(index)) as subscope:
self.json[index].evaluate(item, subscope)
if not subscope.valid:
err_indices += [index]
if err_indices:
scope.fail(instance, f"Array elements {err_indices} are invalid")
elif eval_index is not None:
if eval_index == len(instance) - 1:
eval_index = True
scope.annotate(instance, self.key, eval_index)
def evaluate(self, instance: JSON, scope: Scope) -> None:
matched_names = set()
err_names = []
for name, item in instance.items():
for regex, subschema in self.json.items():
if re.search(regex, name) is not None:
with scope(regex) as subscope:
subschema.evaluate(item, subscope)
if subscope.valid:
matched_names |= {name}
else:
err_names += [name]
if err_names:
scope.fail(instance, f"Properties {err_names} are invalid")
else:
scope.annotate(instance, self.key, list(matched_names))
def evaluate(self, instance: JSON, scope: Scope) -> None:
annotation = []
err_names = []
for name, subschema in self.json.items():
if name in instance:
with scope(name) as subscope:
subschema.evaluate(instance, subscope)
if subscope.valid:
annotation += [name]
else:
err_names += [name]
if err_names:
scope.fail(
instance, f'Properties {err_names} are invalid against '
f'the corresponding "dependentSchemas" subschemas')
else:
scope.annotate(instance, self.key, annotation)
def evaluate(self, instance: JSON, scope: Scope) -> None:
evaluated_names = set()
for properties_annotation in scope.parent.collect_annotations(
instance, "properties"):
evaluated_names |= set(properties_annotation.value)
for pattern_properties_annotation in scope.parent.collect_annotations(
instance, "patternProperties"):
evaluated_names |= set(pattern_properties_annotation.value)
for additional_properties_annotation in scope.parent.collect_annotations(
instance, "additionalProperties"):
evaluated_names |= set(additional_properties_annotation.value)
for unevaluated_properties_annotation in scope.parent.collect_annotations(
instance, "unevaluatedProperties"):
evaluated_names |= set(unevaluated_properties_annotation.value)
annotation = []
for name, item in instance.items():
if name not in evaluated_names:
if self.json.evaluate(item, scope).valid:
annotation += [name]
if scope.valid:
scope.annotate(instance, self.key, annotation)
def evaluate(self, instance: JSON, scope: Scope) -> None:
scope.annotate(instance, self.key, self.json.value)
scope.noassert()