Support constants in JSON schema

[tokarenko]

What do you think about supporting constant values in schema, indicated by the Tuple type, e.g., as follows?

>>> from genson import SchemaBuilder
>>> builder = SchemaBuilder()
>>> builder.add_schema({"type": "object", "properties": {}})
>>> builder.add_object(
    { 
        "attr": ("value",)
    } 
)

Expected result is:
{'$schema': 'http://json-schema.org/schema#',
 'type': 'object',
 'properties': {
    'attr': {"const": "value"}},
    'required': ['attr']}

By the way, the code above raises the following error:
genson.schema.node.SchemaGenerationError: Could not find matching schema type for object: ("value",)

[wolverdude]

The error you're encountering is because the object includes a tuple, but GenSON is designed to handle standard JSON objects, which include only list objects. I don't see a good reason why not to accept tuples though, as this is a perfectly reasonable thing to do in Python even if it isn't technically JSON.

If that were implemented, it wouldn't produce const values though. It would produce tuples unless the user seeds it to produce arrays.

If support for const were implemented, you would need to seed the schema with the const keyword to activate the feature:

>>> from genson import SchemaBuilder
>>> builder = SchemaBuilder()
>>> builder.add_schema({
    "type": "object",
    "properties": {
        "attr": {"const": "value"}
    }
})

After that, you could add objects. There are some complications here:

1. What if you don't know the const value upfront? We'd need some sort of signal value to tell the const SchemaStrategy that it should fill in the value later. Since the value of the const could be anything, you can't use None for that. But we could create our own signal class that isn't a valid JSON value. This could be aliased to something like genson.UNKNOWN_VALUE.
2. What if an object or schema is added that contradicts the existing const value? The two options I see:
   1. Raise an exception, which could be really annoying for someone trying to combine thousands of JSON objects.
   2. Use anyOf to split the schema. Given the current implementation of anyOf, this would result in one const schema while all other values encountered will turn into normal typed schemas. This is somewhat nonintuitive, and I'm not sure it's desirable.
3. Similar to point 2, what if a schema is added where that property isn't a const? anyOf seems like the right answer here, with similar consequences as in point 2.

An alternative with no annoying or nonintuitive side-effects would be to implement enum instead. If you seed with the enum keyword, GenSON would then record a deduplicated list of every value encountered. If in the end, that list contains exactly one item, then you can change it to const yourself.

What do you think? Support tuple? const? enum?

[tokarenko]

Thank you for your exhaustive reply @wolverdude. I think enum will work the best. Moreover, there is no need to substitute enum with const in my case! I may try to provide PR for this. But if you happen to have time to implement, then you definitely will be faster then me )