Best way to extend JSON schema parsing

[WilliamJamieson]

I have been looking into ways to automatically generate data models for a large and growing collection of schemas that I need to work with. After some experimentation and exploration it appears that the datamodel-code-generator appears to be a good project to build what I need off of. However, due to the peculiarities of the schemas I have to work with, the standard JSON schema parser used by datamodel-code-generator (or any similar project) is not sufficient to capture some of the features I need to extract from my schemas. Thus I believe that I will have to do some extensions to the JSON schema parser that is currently present.

For background, the core of my issue is that the schemas in question employ an extension of JSON schema. This extension essentially adds a mechanism, tag, which is roughly equivalent to $ref but it carries additional information. Namely, our application of JSON schema is validation of YAML data which includes sections which are tagged with YAML tags. Our validation of the tag works via validating the data using the schema associated with the specific tag including any refinements using allOf combiners. However, in addition to the $ref-like behavior, the tag listed in the schema is also validated against the YAML tag present. While we currently have a system in place to validate data already written to these YAML files, we do not have a good system (its an entirely ad-hoc data model like scheme) to work with building data to write; hence, the desire to generate data models matching the schemas.

After doing some prototyping with the current version of datamodel-code-generator I have found that I can achieve most of functionality I need. I can do this in two steps:

1. Extending the existing JsonSchemaObject, call it TaggedJsonSchemaObject, to include a tag field and then adding a model_post_init method to that extension which looks up the correct $ref for a given tag and then fills in that information.
2. Extending the JsonSchemaParser to then employ TaggedJsonSchemaObject instead of JsonSchemaObject.

This ends up solving most of the issues I have, but getting the JsonSchemaParser extension to work properly requires duplicating several methods exactly with the only change being replacing JsonSchemaObject with TaggedSchemaObject. These are:

• parse_combined_schema
• parse_raw_obj
• _parse_file

While this approach works, it does not feel like a good approach as it is quite prone to being broken by changes to JsonSchemaParser in the future. Thus my question(s):

• Is there a better alternative approach?
• If not, would datamodel-code-generator be interested in an enhancement to make it easier to replace the JsonSchemaObject in JsonSchemaParser?

Edit:
My suggested enhancement is something akin to these changes.

[koxudaxi]

Thank you for the detailed proposal and use case explanation.

While I understand the value of making JsonSchemaObject more easily swappable in JsonSchemaParser, implementing this properly is technically challenging due to Pydantic's handling of nested type annotations. The self-referential fields (like items, oneOf, allOf, etc.) make it difficult to achieve true extensibility without significant architectural changes.

I'd like to revisit this after v1 is released and the API has stabilized. At that point, we can consider the best approach without risking breaking changes.

Thank you for your contribution and understanding!