Does it support dynamic model generation?

[berislavlopac]

Looking at the documentation, this project generates Python code as text, which can be saved into output files to be used/imported as modules.

With Python's dynamic capabilities, it is quite easy to -- instead of textual code -- generate actual model classes on the fly. Is that supported as a use case at the moment?

[koxudaxi]

@berislavlopac
the short answer is No.
Do you have a concrete idea to realize model generation on the fly?

[berislavlopac]

@koxudaxi Probably the most promising option would be to use Pydantic's create_model function - https://docs.pydantic.dev/usage/models/#dynamic-model-creation

[koxudaxi]

Looks good.
I'm not familiar with create_model.
We should confirm the different specs like module level.
Also, I don't have the time. PR welcome.

[berislavlopac]

Yeah, I hear you with the lack of time. I'm currently exploring the viable options, and have a few thoughts so far:

1. The parser.parse internally builds a collection of models, but they can't be directly accessed; we will need either to extract that into a separate function, or to add an optional argument to parse to make it return the collection.
2. I haven't yet figured out how those models are converted to Pydantic ones, or dataclass; my idea is to use create_model to do that conversion. Not sure yet how it would work with dataclasses exactly, but just getting it to work with Pydantic would be a great starting point.

[koxudaxi]

@berislavlopac

parse() returns model as str. we change the return value or refactoring and add a new method to get a dynamic model.

datamodel-code-generator/datamodel_code_generator/parser/base.py

Lines 955 to 960 in 3c69582

	def parse(
	self,
	with_import: Optional[bool] = True,
	format_: Optional[bool] = True,
	settings_path: Optional[Path] = None,
	) -> Union[str, Dict[Tuple[str, ...], Result]]:

After parsing, the models are created.
The CLI calls __str__ method on the model to render the Jinja template.

datamodel-code-generator/datamodel_code_generator/model/base.py

Lines 196 to 204 in 3c69582

	@abstractmethod
	def render(self) -> str:
	raise NotImplementedError
	def _render(self, *args: Any, **kwargs: Any) -> str:
	return self.template.render(*args, **kwargs)
	def __str__(self) -> str:
	return self.render()

BaseModel is here.

datamodel-code-generator/datamodel_code_generator/model/pydantic/base_model.py

Line 187 in 3c69582

class BaseModel(DataModel):

Dataclass

datamodel-code-generator/datamodel_code_generator/model/dataclass.py

Line 15 in 3c69582

class DataClass(DataModel):

I think we can add create_model method on DataModel.
DataModel has all context to create mode dynamically. https://github.com/koxudaxi/datamodel-code-generator/blob/master/datamodel_code_generator/model/template/pydantic/BaseModel.jinja2

I need to learn how to treat modulable models.
Can we set the namespace(module name) to a dynamic model? 🤔

[berislavlopac]

1. Yes, that's exactly what I meant.

For 2:

I think we can add create_model method on DataModel.

Maybe better on its subclasses, as I expect the mechanism to be different for Pydantic and dataclasses.

DataModel has all context to create mode dynamically

Yes, that was my conclusion.

Can we set the namespace(module name) to a dynamic model?

For dynamically created classes, the module name is __main__:

>>> Foo = type("Foo", (), {})
>>> Foo.__module__
'__main__'

We can probably also use the types library to define namespaces. 🤔

[Danipulok]

@berislavlopac good day. Have you created a PR or something similar in this direction?

[berislavlopac]

I'm afraid not, been too swamped with work. 😞 But it's been on my mind and I keep planning to return to it.

[Danipulok]

Got it, thanks a for a quick reply!
Good luck