json-schema-utils 0.8__tar.gz → 0.8.2__tar.gz

{json_schema_utils-0.8 → json_schema_utils-0.8.2}/Makefile

@@ -39,7 +39,7 @@ check.ruff: venv
 .PHONY: check.flake8
 check.flake8: venv
 	source venv/bin/activate
-	flake8 --ignore=$(IGNORE),W504 --max-line-length=100 jsutils
+	flake8 --ignore=$(IGNORE),E128,E131,W504 --max-line-length=100 jsutils
 
 .PHONY: check.pyright
 check.pyright: venv

{json_schema_utils-0.8 → json_schema_utils-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json_schema_utils
-Version: 0.8
+Version: 0.8.2
 Summary: JSON Schema Utils
 Author: Fabien Coelho, Claire Yannou-Medrala
 License-Expression: CC0-1.0
@@ -28,7 +28,9 @@ Random utilities to analyze and manipulate JSON Schema.
 
 ## Installation
 
-Install latest version with `pip` from PyPI or from GitHub:
+Install latest version with `pip` from
+[PyPI](https://pypi.org/project/json-schema-utils) or directly from
+[GitHub](https://github.com/zx80/json-schema-utils):
 
 ```sh
 python -m venv venv

{json_schema_utils-0.8 → json_schema_utils-0.8.2}/README.md

@@ -4,7 +4,9 @@ Random utilities to analyze and manipulate JSON Schema.
 
 ## Installation
 
-Install latest version with `pip` from PyPI or from GitHub:
+Install latest version with `pip` from
+[PyPI](https://pypi.org/project/json-schema-utils) or directly from
+[GitHub](https://github.com/zx80/json-schema-utils):
 
 ```sh
 python -m venv venv

{json_schema_utils-0.8 → json_schema_utils-0.8.2}/json_schema_utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json_schema_utils
-Version: 0.8
+Version: 0.8.2
 Summary: JSON Schema Utils
 Author: Fabien Coelho, Claire Yannou-Medrala
 License-Expression: CC0-1.0
@@ -28,7 +28,9 @@ Random utilities to analyze and manipulate JSON Schema.
 
 ## Installation
 
-Install latest version with `pip` from PyPI or from GitHub:
+Install latest version with `pip` from
+[PyPI](https://pypi.org/project/json-schema-utils) or directly from
+[GitHub](https://github.com/zx80/json-schema-utils):
 
 ```sh
 python -m venv venv

{json_schema_utils-0.8 → json_schema_utils-0.8.2}/jsutils/convert.py

@@ -84,7 +84,7 @@ def numberConstraints(schema):
     return constraints
 
 
-def buildModel(model, constraints: dict, defs: dict, sharp: dict, is_root = False):
+def buildModel(model, constraints: dict, defs: dict, sharp: dict, is_root: bool = False):
     if constraints or sharp or defs:
 
         if constraints:
@@ -125,7 +125,7 @@ SPLITS = {
     "array": ["minItems", "maxItems", "uniqueItems", "items", "prefixItems", "contains",
               "minContains", "maxContains"],
     "object": ["properties", "required", "additionalProperties", "minProperties", "maxProperties",
-                "patternProperties", "propertyNames"],
+               "patternProperties", "propertyNames"],
 }
 
 SPLIT = {}
@@ -197,7 +197,7 @@ def split_schema(schema: dict[str, Any]) -> dict[str, dict[str, Any]]:
 
 # identifiers
 CURRENT_SCHEMA: str|None = None
-SCHEMA: str|None = None
+SCHEMA = None
 IDS: dict[str, dict[str, Any]] = {}
 EXPLICIT_TYPE: bool = False
 
@@ -251,7 +251,6 @@ def doubt(ok: bool, msg: str, strict: bool):
         else:
             log.warning(msg)
 
-
 def allOfLayer(schema: dict, operator: str):
     # log.warning(f"ao {operator} in: {schema}")
     schemas = copy.deepcopy(schema[operator])
@@ -273,7 +272,8 @@ def allOfLayer(schema: dict, operator: str):
 
 
 # TODO handle a global defs so as to be able to create new ones
-def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool = True):
+def schema2model(schema, path: JsonPath = [],
+                 strict: bool = True, fix: bool = True, is_root: bool = True):
     """Convert a JSON schema to a JSON model assuming a 2020-12 semantics."""
 
     global CURRENT_SCHEMA, SCHEMA
@@ -320,9 +320,9 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
             # keep json schema for handling $ref #
             IDS[dname][encoded] = val
             # provide a local converted version as well? not enough??
-            defs[encoded] = schema2model(val, path + [dname, name], strict, False)
+            defs[encoded] = schema2model(val, path + [dname, name], strict, fix, False)
         # special root handling
-        IDS[""] = "$#"
+        IDS[dname][""] = "$#"
 
     # FIXME cleanup OpenAPI extentions "x-*", nullable
     for prop in list(schema.keys()):
@@ -465,36 +465,36 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
         choices = schema["oneOf"]
         assert isinstance(choices, list), f"oneOf list at [{spath}]"
         if only(schema, "oneOf", *IGNORE):
-            model = {"^": [schema2model(s, path + ["oneOf", i], strict, False)
-                        for i, s in enumerate(choices)]}
+            model = {"^": [schema2model(s, path + ["oneOf", i], strict, fix, False)
+                         for i, s in enumerate(choices)]}
             return buildModel(model, {}, defs, sharp, is_root)
         else:  # try building an "allOf" layer
             log.warning(f"keyword oneOf intermixed with other keywords at [{spath}]")
             ao = allOfLayer(schema, "oneOf")
-            return schema2model(ao, path + ["oneOf"], strict, False)
+            return schema2model(ao, path + ["oneOf"], strict, fix, False)
     elif "anyOf" in schema:
         choices = schema["anyOf"]
         assert isinstance(choices, (list, tuple)), f"anyOf list at [{spath}]"
         if only(schema, "anyOf", *IGNORE):
-            model = {"|": [schema2model(s, path + ["anyOf", i], strict, False)
+            model = {"|": [schema2model(s, path + ["anyOf", i], strict, fix, False)
                         for i, s in enumerate(choices)]}
             return buildModel(model, {}, defs, sharp, is_root)
         else:
             log.warning(f"keyword anyOf intermixed with other keywords at [{spath}]")
             ao = allOfLayer(schema, "anyOf")
-            return schema2model(ao, path + ["anyOf"], strict, False)
+            return schema2model(ao, path + ["anyOf"], strict, fix, False)
     elif "allOf" in schema:
         # NOTE types should be compatible to avoid an empty match
         choices = schema["allOf"]
         assert isinstance(choices, (list, tuple)), f"allOf list at [{spath}]"
         if only(schema, "allOf", *IGNORE):
-            model = {"&": [schema2model(s, path + ["allOf", i], strict, False)
+            model = {"&": [schema2model(s, path + ["allOf", i], strict, fix, False)
                         for i, s in enumerate(choices)]}
             return buildModel(model, {}, defs, sharp, is_root)
         else:  # build another allOf layer
             log.warning(f"keyword allOf intermixed with other keywords at [{spath}]")
             ao = allOfLayer(schema, "allOf")
-            return schema2model(ao, path + ["allOf"], strict, False)
+            return schema2model(ao, path + ["allOf"], strict, fix, False)
     elif "not" in schema:
         val = schema["not"]
         assert isinstance(val, dict), "not object at [{spath}]"
@@ -502,12 +502,12 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
             if len(val) == 0:
                 model = "$NONE"
             else:
-                model = {"^": ["$ANY", schema2model(val, path + ["not"], strict, False)]}
+                model = {"^": ["$ANY", schema2model(val, path + ["not"], strict, fix, False)]}
             return buildModel(model, {}, defs, sharp, is_root)
         else:  # add a allOf layer
             log.warning(f"keyword not intermixed with other keywords at [{spath}]")
             ao = allOfLayer(schema, "not")
-            return schema2model(ao, path + ["not"], strict, False)
+            return schema2model(ao, path + ["not"], strict, fix, False)
 
     # handle simpler schemas
     if "$ref" in schema:
@@ -534,7 +534,8 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                 if names and names[0] in ("$defs", "definitions"):
                     val = IDS
                     for name in names:
-                        assert name in val, f"following path in {ref}: missing {name} ({IDS}) at [{spath}]"
+                        assert name in val, \
+                            f"following path in {ref}: missing {name} ({IDS}) at [{spath}]"
                         val = val[name]
                 else:  # arbitrary path
                     val = SCHEMA
@@ -543,13 +544,13 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                             name = unquote(name).replace("~1", "/").replace("~0", "~")
                         assert name in val, f"following path in {ref}: missing {name} at [{spath}]"
                         val = val[name]
-                model = schema2model(val, path + ["$ref"], strict, False)
+                model = schema2model(val, path + ["$ref"], strict, fix, False)
                 return buildModel(model, {}, defs, sharp, is_root)
             else:
                 assert False, f"$ref handling not implemented: {ref}"
         else:
             log.warning(f"$ref intermixed with other keywords at [{spath}]")
-            return schema2model(allOfLayer(schema, "$ref"), path, strict, False)
+            return schema2model(allOfLayer(schema, "$ref"), path, strict, fix, False)
 
     elif "type" in schema:
         ts = schema["type"]
@@ -559,7 +560,8 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
             return buildModel(
                 {
                     "|": [
-                        schema2model(v, path + ["typeS"], strict, False) for v in schemas.values()
+                        schema2model(v, path + ["typeS"], strict, fix, False)
+                            for v in schemas.values()
                     ]
                 }, {}, defs, sharp, is_root)
         elif ts == "string" and "const" in schema:
@@ -618,7 +620,7 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
         elif ts == "number":
             doubt(only(schema, "type", "format", "multipleOf", "minimum", "maximum",
                        "exclusiveMinimum", "exclusiveMaximum", *IGNORE),
-                        f"number properties at [{spath}]", strict)
+                  f"number properties at [{spath}]", strict)
             model = "$NUMBER" if EXPLICIT_TYPE else -1.0
             if "format" in schema:
                 fmt = schema["format"]
@@ -640,7 +642,7 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
         elif ts == "integer":
             doubt(only(schema, "type", "format", "multipleOf", "minimum", "maximum",
                        "exclusiveMinimum", "exclusiveMaximum", *IGNORE),
-                        f"integer properties at [{spath}]", strict)
+                  f"integer properties at [{spath}]", strict)
             model = "$INTEGER" if EXPLICIT_TYPE else -1
             # OpenAPI
             if "format" in schema:
@@ -668,23 +670,33 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
             return buildModel(model, {}, defs, sharp, is_root)
 
         elif ts == "array":
-            # fix common misplacements
-            if not strict and "items" in schema and isinstance(schema["items"], dict):
-                subschema = schema["items"]
-                for kw in ("uniqueItems", "minItems", "maxItems"):
-                    # possible move misplaced uniqueItems
-                    if kw not in schema and kw in subschema and "type" in subschema and \
-                            isinstance(subschema["type"], str) and subschema["type"] != "array":
-                        log.warning(f"moving misplaced {kw} at [{spath}.items]")
-                        schema[kw] = subschema[kw]
-                        del subschema[kw]
-            # TODO minLength -> minItems
+            if fix:
+                # common misplacements
+                if not strict and "items" in schema and isinstance(schema["items"], dict):
+                    subschema = schema["items"]
+                    for kw in ("uniqueItems", "minItems", "maxItems"):
+                        # possible move misplaced keyword
+                        if kw not in schema and kw in subschema and "type" in subschema and \
+                                isinstance(subschema["type"], str) and subschema["type"] != "array":
+                            log.warning(f"moving misplaced {kw} at [{spath}.items]")
+                            schema[kw] = subschema[kw]
+                            del subschema[kw]
+                # common misnamings
+                rename = { "minLength": "minItems", "maxLength": "maxItems" }
+                for kw in rename:
+                    if kw in schema:
+                        if rename[kw] not in schema:
+                            log.warning(f"renaming {kw} to {rename[kw]} at [{spath}]")
+                            schema[rename[kw]] = schema[kw]
+                        else:
+                            log.warning(f"removing useless {kw} at [{spath}]")
+                        del schema[kw]
 
             # sanity check
             doubt(only(schema, "type", "prefixItems", "items",
                        "contains", "minContains", "maxContains",
                        "minItems", "maxItems", "uniqueItems", *IGNORE),
-                       f"array properties at [{spath}]", strict)
+                  f"array properties at [{spath}]", strict)
 
             # build model
             constraints = {}
@@ -715,7 +727,7 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                 vpi = schema["prefixItems"]
                 assert isinstance(vpi, list), f"list prefixItems at [{spath}]"
                 model = [
-                    schema2model(s, path + ["prefixItems", i], strict, False)
+                    schema2model(s, path + ["prefixItems", i], strict, fix, False)
                         for i, s in enumerate(vpi)
                 ]
                 if "items" in schema:
@@ -723,11 +735,13 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                     if isinstance(schema["items"], bool):
                         assert not constraints, f"not implemented yet at [{spath}]"
                         if not schema["items"]:
-                            return buildModel(model, {">=": 0, "<=": len(model)}, defs, sharp, is_root)
+                            return buildModel(model, {">=": 0, "<=": len(model)},
+                                              defs, sharp, is_root)
                         else:
                             assert False, f"not implemented yet at [{spath}]"
                     # items is a type
-                    model.append(schema2model(schema["items"], path + ["items"], strict, False))
+                    model.append(schema2model(schema["items"], path + ["items"],
+                                              strict, fix, False))
                     if not constraints:
                         constraints[">="] = len(model) - 1
                     return buildModel(model, constraints, defs, sharp, is_root)
@@ -743,7 +757,7 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                 if isinstance(sitems, list):
                     # OLD JSON Schema prefixItems…
                     array = [
-                        schema2model(s, path + ["items", i], strict, False)
+                        schema2model(s, path + ["items", i], strict, fix, False)
                             for i, s in enumerate(sitems)
                     ]
                     if strict:
@@ -753,7 +767,7 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                         return { "@": array, ">=": 0 }
                 else:
                     assert isinstance(sitems, (dict, bool)), f"valid schema at [{spath}]"
-                    model = [schema2model(schema["items"], path + ["items"], strict, False)]
+                    model = [schema2model(schema["items"], path + ["items"], strict, fix, False)]
                     return buildModel(model, constraints, defs, sharp, is_root)
             elif "contains" in schema:
                 # NO contains/items mixing yet
@@ -762,7 +776,7 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                 # NOTE contains is not really supported in jm v2, or rather as an extension
                 model = {
                     "@": ["$ANY"],
-                    ".in": schema2model(schema["contains"], path + ["contains"], strict, False)
+                    ".in": schema2model(schema["contains"], path + ["contains"], strict, fix, False)
                 }
                 if "minContains" in schema:
                     mini = schema["minContains"]
@@ -783,14 +797,17 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                 log.warning(f"ignoring discriminator at [{spath}]")
                 del schema["discriminator"]
 
-            # fix additionalProperties misplacement
-            if not strict and "properties" in schema and isinstance(schema["properties"], dict) \
-                    and "additionalProperties" not in schema \
-                    and "additionalProperties" in schema["properties"] \
-                    and "properties" not in schema["properties"]:
-                log.warning(f"moving misplaced additionalProperties at [{spath}.properties]")
-                schema["additionalProperties"] = schema["properties"]["additionalProperties"]
-                del schema["properties"]["additionalProperties"]
+            if fix:
+                # common misplacements
+                if not strict and "properties" in schema and isinstance(schema["properties"], dict):
+                    properties = schema["properties"]
+                    for kw in ["additionalProperties", "unevaluatedProperties",
+                               "minProperties", "maxProperties"]:
+                        if kw in properties:
+                            if kw not in schema:
+                                log.warning(f"moving misplaced {kw} at [{spath}.properties]")
+                                schema[kw] = properties[kw]
+                                del properties[kw]
 
             # sanity check
             doubt(only(schema, "type", "properties", "additionalProperties", "required",
@@ -819,13 +836,13 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                 assert isinstance(pats, dict), f"dict pattern props at [{spath}]"
                 for pp in sorted(pats.keys()):
                     model[f"/{pp}/"] = \
-                        schema2model(pats[pp], path + ["patternProperties", pp], strict, False)
+                        schema2model(pats[pp], path + ["patternProperties", pp], strict, fix, False)
 
             if "propertyNames" in schema:
                 # does not seem very useful?
                 pnames = schema["propertyNames"]
                 if "additionalProperties" in schema:
-                    target = schema2model(schema["additionalProperties"], path, strict, False)
+                    target = schema2model(schema["additionalProperties"], path, strict, fix, False)
                 else:
                     target = "$ANY"
 
@@ -852,10 +869,10 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                 for k, v in props.items():
                     if k in required:
                         model[f"_{k}"] = \
-                            schema2model(v, path + ["properties", f"_{k}"], strict, False)
+                            schema2model(v, path + ["properties", f"_{k}"], strict, fix, False)
                     else:
                         model[f"?{k}"] = \
-                            schema2model(v, path + ["properties", f"?{k}"], strict, False)
+                            schema2model(v, path + ["properties", f"?{k}"], strict, fix, False)
                 if "additionalProperties" in schema:
                     ap = schema["additionalProperties"]
                     if isinstance(ap, bool):
@@ -863,7 +880,8 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                             model[""] = "$ANY"
                         # else nothing else is allowed
                     elif isinstance(ap, dict):
-                        model[""] = schema2model(ap, path + ["additionalProperties"], strict, False)
+                        model[""] = schema2model(ap, path + ["additionalProperties"],
+                                                 strict, fix, False)
                     else:
                         assert False, f"not implemented yet at [{spath}]"
                 else:
@@ -873,7 +891,7 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                 # "additionalProperties" without "properties" or "patternProperties"
                 doubt(only(schema, "type", "additionalProperties", "maxProperties", "minProperties",
                            "properties", "patternProperties", *IGNORE),
-                           f"add prop props at [{spath}]", strict)
+                      f"add prop props at [{spath}]", strict)
                 if "properties" not in schema and "additionalProperties" not in schema and strict:
                     assert False, "additionalProperties without properties or patternProperties"
                 ap = schema["additionalProperties"]
@@ -882,7 +900,8 @@ def schema2model(schema, path: JsonPath = [], strict: bool = True, is_root: bool
                         model[""] = "$ANY"
                     # else nothing else is allowed
                 elif isinstance(ap, dict):
-                    model[""] = schema2model(ap, path + ["additionalProperties"], strict, False)
+                    model[""] = schema2model(ap, path + ["additionalProperties"],
+                                             strict, fix, False)
                 else:
                     assert False, f"not implemented yet at [{spath}]"
 

{json_schema_utils-0.8 → json_schema_utils-0.8.2}/jsutils/scripts.py

@@ -164,7 +164,7 @@ def jsu_check():
 
     # be nice
     if isinstance(jschema, dict) and "$schema" not in jschema:
-        jschema["$schema"] = f"https://json-schema.org/draft/{args.version}/schema"
+        jschema["$schema"] = f"https://json-schema.org/draft/{args.draft}/schema"
 
     try:
         if args.engine == "jschon":
@@ -297,6 +297,7 @@ def jsu_pretty():
         schema = json.load(open(fn) if fn != "-" else sys.stdin)
         print(json_dumps(schema, args))
 
+
 GH = "https://raw.githubusercontent.com"
 SS = "https://json.schemastore.org"
 # JM = f"{GH}/clairey-zx81/json-model/main/models"
@@ -354,12 +355,15 @@ def jsu_model():
     from .convert import schema2model
 
     ap = argparse.ArgumentParser()
+    arg = ap.add_argument
     ap_common(ap)
-    ap.add_argument("--id", action="store_true", default=False, help="enable $id lookup")
-    ap.add_argument("--no-id", dest="id", action="store_false", help="disable $id lookup")
-    ap.add_argument("--strict", action="store_true", default=True, help="reject doubtful schemas")
-    ap.add_argument("--loose", dest="strict", action="store_false", help="accept doubtful schemas")
-    ap.add_argument("schemas", nargs="*", help="schemas to process")
+    arg("--id", action="store_true", default=False, help="enable $id lookup")
+    arg("--no-id", dest="id", action="store_false", help="disable $id lookup")
+    arg("--strict", action="store_true", default=True, help="reject doubtful schemas")
+    arg("--loose", dest="strict", action="store_false", help="accept doubtful schemas")
+    arg("--fix", "-F", action="store_true", default=True, help="fix common schema issues")
+    arg("--no-fix", "-nF", dest="fix", action="store_false", help="do not fix common schema issues")
+    arg("schemas", nargs="*", help="schemas to process")
     args = ap.parse_args()
 
     log.setLevel(logging.DEBUG if args.debug else logging.WARNING if args.quiet else logging.INFO)
@@ -386,7 +390,7 @@ def jsu_model():
                     log.info(f"using predefined model for {sid}")
                     model = f"${ID2MODEL[sid][0 if args.strict else 1]}"
             if model is None:
-                model = schema2model(schema, strict=args.strict)
+                model = schema2model(schema, strict=args.strict, fix=args.fix)
         except Exception as e:
             log.error(e, exc_info=args.debug)
             errors += 1

{json_schema_utils-0.8 → json_schema_utils-0.8.2}/jsutils/simplify.py

@@ -84,6 +84,7 @@ def _typeCompat(t: str, v: Any) -> bool:
             (t == "array" and isinstance(v, (list, tuple))) or
             (t == "object" and isinstance(v, dict)))
 
+
 _IGNORABLE = (
     # core
     "$schema", "$id", "$comment", "$vocabulary", "$anchor", "$dynamicAnchor",
@@ -131,6 +132,7 @@ def simplifySchema(schema: JsonSchema, url: str):
     # FIXME check that there is only one dynamicAnchor of this name?!
     dynroot: str|None = None
     if isinstance(schema, dict) and "$dynamicAnchor" in schema:
+        assert isinstance(schema["$dynamicAnchor"], str)
         dynroot = schema["$dynamicAnchor"]
         del schema["$dynamicAnchor"]
 
@@ -216,6 +218,7 @@ def simplifySchema(schema: JsonSchema, url: str):
         for kw in ("then", "else"):
             if kw in schema:
                 subs = schema[kw]
+                assert isinstance(subs, dict)
                 compat = True
                 for k, v in subs.items():
                     if k in _IGNORABLE:
@@ -225,6 +228,7 @@ def simplifySchema(schema: JsonSchema, url: str):
                     elif k in schema:
                         # special case, check for inclusion
                         if k == "required":
+                            assert "required" in schema and isinstance(schema["required"], list)
                             assert isinstance(v, list)  # and str
                             for n in v:
                                 if n not in schema["required"]:
@@ -248,6 +252,7 @@ def simplifySchema(schema: JsonSchema, url: str):
         # simplify condition if possible
         if "if" in schema:
             cond = schema["if"]
+            assert isinstance(cond, dict)
             if "not" in cond and only(cond, "not", *_IGNORABLE):
                 log.info("simplifying if not")
                 schema["if"] = cond["not"]
@@ -340,11 +345,14 @@ def simplifySchema(schema: JsonSchema, url: str):
                 if "propertyNames" in schema and "additionalProperties" in schema and \
                         "properties" not in schema and "patternProperties" not in schema:
                     pn = schema["propertyNames"]
+                    assert isinstance(pn, dict)
                     ap = schema["additionalProperties"]
                     if "pattern" in pn and only(pn, "pattern", "type", *_IGNORABLE):
-                        log.info(f"switching propertyNames and additionalProperties to patternProperties at {lpath}")
+                        log.info("switching propertyNames and additionalProperties to "
+                                 f"patternProperties at {lpath}")
                         del schema["propertyNames"]
                         del schema["additionalProperties"]
+                        assert isinstance(pn["pattern"], str)
                         schema["patternProperties"] = { pn["pattern"]: ap }
 
         # const/enum
@@ -370,11 +378,13 @@ def simplifySchema(schema: JsonSchema, url: str):
 
     return recurseSchema(schema, url, rwt=rwtSimpler)
 
+
 #
 # move definitions at the root and resolve ids
 #
 from urllib.parse import quote, unquote
 
+
 def _defId(schema) -> tuple[str|None, str|None]:
     """return name of definitions and id properties."""
     if not isinstance(schema, dict):
@@ -387,29 +397,38 @@ def _defId(schema) -> tuple[str|None, str|None]:
           None
     return (defn, idn)
 
+
 _SUBCOUNT: int = 0
 
 # TODO handle arbitrary path references
 
 def _scopeSubDefs(schema: JsonSchema, defs: dict[str, JsonSchema], rootdef: str,
-                  moved: dict[str, str], ids: dict[str, str], delete: list[tuple[Any, str]],
+                  moved: dict[str, str], ids: dict[str, str],
+                  delete: list[tuple[Any, str, str|None, str|None, str|None]],
                   path: list[str|int] = []):
 
     log.debug(f"handing $ids/$defs at {path}")
 
     global _SUBCOUNT
     defn, idn = _defId(schema)
-
     if defn is None:
         return
 
+    assert isinstance(schema, dict)
+    assert isinstance(defn, str)
+    sdefs = schema[defn]
+    assert isinstance(sdefs, dict)
+
     if path and defn and not idn:
         # nested definitions, move them up
 
         prefix = f"_defs_{_SUBCOUNT}_"
         _SUBCOUNT += 1
 
-        for name, sschema in schema[defn].items():
+        for name, sschema in sdefs.items():
+
+            assert isinstance(sschema, dict)
+
             # FIXME name may be quite ugly… eg a full URL
             if "/" not in name:  # reuse name if simple
                 new_name = prefix + name
@@ -419,7 +438,7 @@ def _scopeSubDefs(schema: JsonSchema, defs: dict[str, JsonSchema], rootdef: str,
                 _SUBCOUNT += 1
                 old_name = quote(name).replace("~", "~0").replace("/", "~1")
             npath = rootdef + "/" + new_name
-            opath = f"#/{'/'.join(path)}/{defn}/{old_name}"
+            opath = f"#/{'/'.join(path)}/{defn}/{old_name}"  # type: ignore
             sschema["$comment"] = f"origin: {opath}"
             moved[opath] = npath
             defs[new_name] = sschema
@@ -468,9 +487,10 @@ def _scopeSubDefs(schema: JsonSchema, defs: dict[str, JsonSchema], rootdef: str,
         recurseSchema(schema, "", rwt=rwtRef)
 
         # move local definitions as global
-        for name, sschem in schema[defn].items():
+        for name, sschem in sdefs.items():
             pname = prefix + name
             assert pname not in defs
+            assert isinstance(sschem, (bool, dict))
             defs[pname] = sschem
 
         # we need to keep the schema in place for handling arbitrary url
@@ -499,6 +519,7 @@ def scopeDefs(schema: JsonSchema):
         return
 
     # ensure definitions root
+    assert isinstance(schema, dict)
     defn, idn = _defId(schema)
 
     if defn is None:
@@ -509,10 +530,10 @@ def scopeDefs(schema: JsonSchema):
     rootdef, moved, ids, delete = f"#/{defn}", {}, {}, []
 
     for s, p in todo_ids:
-        _scopeSubDefs(s, schema[defn], rootdef, moved, ids, delete, p)
+        _scopeSubDefs(s, schema[defn], rootdef, moved, ids, delete, p)  # type: ignore
 
     for s, p in todo_defs:
-        _scopeSubDefs(s, schema[defn], rootdef, moved, ids, delete, p)
+        _scopeSubDefs(s, schema[defn], rootdef, moved, ids, delete, p)  # type: ignore
 
     # move arbitrary references
     def mvRef(rschema, path):
@@ -529,7 +550,7 @@ def scopeDefs(schema: JsonSchema):
                             # hmmm
                             if segment in jdest:
                                 jdest = jdest[segment]
-                            elif "~" in segment  or "%" in segment:
+                            elif "~" in segment or "%" in segment:
                                 segment = unquote(segment).replace("~1", "/").replace("~0", "~")
                                 jdest = jdest[segment]
                         elif isinstance(jdest, list):
@@ -541,7 +562,7 @@ def scopeDefs(schema: JsonSchema):
                     _SUBCOUNT += 1
                     ndest = f"#/{defn}/{name}"
                     # log.info(f"moving {dest} to {ndest}")
-                    schema[defn][name] = copy.deepcopy(jdest)
+                    schema[defn][name] = copy.deepcopy(jdest)  # type: ignore
                     rschema["$ref"] = ndest
                     moved[dest] = ndest  # for other identical references
                 # TODO also rename ugly references?
@@ -574,7 +595,7 @@ def scopeDefs(schema: JsonSchema):
         del j[n]
         if prefix is not None:
             # move whole id-ed object as global as well, replaced with a ref
-            schema[defn][prefix] = { p: s for p, s in j.items() }
+            schema[defn][prefix] = { p: s for p, s in j.items() }  # type: ignore
             j.clear()
             j["$comment"] = f"{sid} moved as $def"
             j["$ref"] = dest

{json_schema_utils-0.8 → json_schema_utils-0.8.2}/jsutils/stats.py

@@ -122,6 +122,8 @@ PER_TYPE = {
     "combi": [ "allOf", "anyOf", "oneOf", "if", "then", "else", "not" ],
 }
 
+IGNORABLE = { kw for kw in PER_TYPE["meta"] }
+
 PROP_TO_TYPE: dict[str, str] = {}
 for t, props in PER_TYPE.items():
     for prop in props:
@@ -887,6 +889,15 @@ def _json_schema_stats_rec(
     elif "then" in jdata or "else" in jdata:
         collectErr(collection, "cond error", "then/else no if", path)
 
+    #
+    # $ref on draft 7 and prior tells to ignore all adjacent keywords!
+    #
+    # https://json-schema.org/draft-07/draft-handrews-json-schema-01#rfc.section.8.3
+    # _All other properties in a "$ref" object MUST be ignored._
+    if "$ref" in jdata and 0 < collection["<version>"] <= 7:
+        if not set(jdata.keys()).issubset(IGNORABLE | {"$ref"}):
+            collectErr(collection, "ignore error", "adjacent keywords next to $ref", path)
+
     # scan all properties
     for prop, val in jdata.items():
 

{json_schema_utils-0.8 → json_schema_utils-0.8.2}/pyproject.toml

@@ -8,7 +8,7 @@ exclude = ["tests*"]
 
 [project]
 name = "json_schema_utils"
-version = "0.8"
+version = "0.8.2"
 authors = [ { name = "Fabien Coelho" }, { name = "Claire Yannou-Medrala" } ]
 description = "JSON Schema Utils"
 readme = "README.md"