at: "npcs": { "$ref": "#/definitions/NpcEntry" }

change "npcs" to "items". npcs is not a valid keyword so it is ignored. The only validation that is happening is at the top level, verifying that the data is an object and that the one property is an array.

"items": {"type": data_schema} should just be "items": data_schema.

Try the following. Essentially map each list to a new list with either the value or None.

alist = [[105, 'A', 'B'],
         [102, 'B', 'C'],
         [111, 'A', 'B', 'C'],
         [106, 'B'],
         [100, 'A', 'C']]

alist = map(lambda x: [x[0] ,
                  "A" if "A" in x else "None",
                  "B" if "B" in x else "None",
                  "C" if "C" in x else "None"], alist)

alternatively: You can just have a list of values the list should have and map that list instead.

values =   ["A","B", "C", "D"]
alist = list(map(lambda x: [x[0]] + #ID 
                            list(map(lambda y: y if y in x else "None", values)), alist))

You have defined your schema correctly, except that it doesn't match the data you say you are validating. If you change the property names to match the schema, you still have one issue. If you want to allow "toll" and "message" to be null, you can do the following.

{
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "loc": {
        "type": "string"
      },
      "toll": {
        "type": ["string", "null"]
      },
      "message": {
        "type": ["string", "null"]
      }
    },
    "required": [
      "loc"
    ]
  }
}

However, that isn't related to the error message you are getting. That message means that data you are validating is not an array. The example data you posted should not result in this error. Are you running the validator on some data other than what is posted in the question?

For a single level array of strings:

{
  "type": "array",
  "items": {
    "type": "string"
  },
  "uniqueItems": true
}

You can make the items schema recursive by allowing it to be an array of arrays, or strings:

{
  "$defs": {
    "nested_array": {
      "type": "array",
      "items": {
        "anyOf": [
          { "type": "string" },
          { "$ref": "#/$defs/nested_array" }
        ]
      },
      "uniqueItems": true
    }
  },
  "$ref": "#/$defs/nested_array"
}

reference: https://json-schema.org/understanding-json-schema/reference/array.html

You can only validate against one schema at a time, but that schema can reference ($ref) external schemas. These references are usually URIs that can be used to GET the schema. A filepath might work too if your schemas are not public. Using a fixed up version of your example, this would look something like this ...

http://your-domain.com/schema/person

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "title": "Person",
  "allOf": [{ "$ref": "http://your-domain.com/schema/base#" }],
  "properties": {
    "type": { "enum": ["person"] },
    "content": {
      "properties": {
        "address": { "$ref": "http://your-domain.com/schema/base#/definitions/location" }
      },
      "required": ["address"],
      "additionalProperties": false
    }
  }
}

http://your-domain.com/schema/base

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "title": "base",
  "type": "object",
  "properties": {
    "content": { "type": "object" },
    "type": { "type": "string" }
  },
  "required": ["type", "content"],
  "additionalProperties": false,
  "definitions": {
    "location": {
      "type": "object",
      "properties": {
        "country": {
          "type": "string",
          "pattern": "^[A-Z]{2}$"
        },
        "name": { "type": "string" }
      },
      "required": ["name", "country"],
      "additionalProperties": false
    }
  }
}

Some documentation that might be useful

• https://python-jsonschema.readthedocs.org/en/latest/validate/#the-validator-interface
• https://python-jsonschema.readthedocs.org/en/latest/references/