If the behaviour is the same to all classes and they all have the same reason to change, then I'd probably not subclass at all.

It is a matter of instantiation and configuration - it only affects the usage of the class but not the structure. So basically we are talking about trade offs in the usage of the class and its maintenance.

If you have an easy time instanatiating your objects from a datasource like you use for generating the classes, then why not do so? If the constructor only takes three easy to remember or easy to look up arguments, why subclass? There's no reason to create so many classes.

Generating the classes on the other hand can turn out to be harder maintenance, as you need to maintain the base class and also the generators if for some reason - and contrary to your expectations - things change.

I can only think of one reason to opt for the subclasses: When it makes your API significantly simpler and your code easier to understand. For example when your class is instantiated very often by the programmer and it's easier for her/him to remember the classname instead of a hard to remember qualifier for the data that is to be fetched from the text file. Or if you absolutely can not fetch the data with a qualifier and the programmer has to lookup or calculate a lot of values to instantiate the class. IMHO that's some sort of convention over configuration then and can really turn out to be an API enhancement - especially if the subclass is the natural place to search for the values if a programmer needs to look them up. But in many cases you should also be able to adjust your data source format in a way that humans can easily interact with it.

Another reason to generate sublasses is when - also contrary to your expectations - you realize that you will need enhanced behaviour on at least some of them.

To be clear, my language (Python) doesn't support interfaces that I'm aware of - some of the other similar questions seemed to get answers recommending that.

That is because dynamically typed language don't need interfaces. Mose use duck typing.

If the behaviour is the same to all classes and they all have the same reason to change, then I'd probably not subclass at all.

It is a matter of instantiation and configuration - it only affects the usage of the class but not the structure. So basically we are talking about trade offs in the usage of the class and its maintenance.

If you have an easy time instanatiating your objects from a datasource like you use for generating the classes, then why not do so? If the constructor only takes three easy to remember or easy to look up arguments, why subclass? There's no reason to create so many classes.

Generating the classes on the other hand can turn out to be harder maintenance, as you need to maintain the base class and also the generators if for some reason - and contrary to your expectations - things change.

I can only think of one reason to opt for the subclasses: When it makes your API significantly simpler and your code easier to understand. For example when your class is instantiated very often by the programmer and it's easier for her/him to remember the classname instead of a hard to remember qualifier for the data that is to be fetched from the datasource. Or if you absolutely can not fetch the data with a qualifier and the programmer has to lookup or calculate a lot of values to instantiate the class. IMHO that's some sort of convention over configuration then and can really turn out to be an API enhancement - especially if the subclass is the natural place to search for the values if a programmer needs to look them up. But in many cases you should also be able to adjust your data source format in a way that humans can easily interact with it.

Another reason to generate sublasses is when - also contrary to your expectations - you realize that you will need enhanced behaviour on at least some of them.

To be clear, my language (Python) doesn't support interfaces that I'm aware of - some of the other similar questions seemed to get answers recommending that.

That is because dynamically typed language don't need interfaces. Mose use duck typing.

If the behaviour is the same to all classes and they all have the same reason to change, then I'd probably not subclass at all.

It is a matter of instantiation and configuration - it only affects the usage of the class but not the structure. So basically we are talking about trade offs in the usage of the class and its maintenance.

If you have an easy time instanatiating your objects from a datasource like you use for generating the classes, then why not do so? If the constructor only takes three easy to remember or easy to look up arguments, why subclass? There's no reason to create so many classes.

Generating the classes on the other hand can turn out to be harder maintenance, as you need to maintain the base class and also the generators if for some reason - and contrary to your expectations - things change.

I can only think of one reason to opt for the subclasses: When it makes your API significantly simpler and your code easier to understand. For example when your class is instantiated very often by the programmer and it's easier for her/him to remember the classname instead of a hard to remember qualifier for the data that is to be fetched from the text file. Or if you absolutely can not fetch the data with a qualifier and the programmer has to lookup or calculate a lot of values to instantiate the class. IMHO that's some sort of convention over configuration then and can really turn out to be an API enhancement. But in many cases you should also be able to adjust your data source format in a way that humans can easily interact with it.

Another reason to generate sublasses is when - also contrary to your expectations - you realize that you will need enhanced behaviour on at least some of them.

If the behaviour is the same to all classes and they all have the same reason to change, then I'd probably not subclass at all.

It is a matter of instantiation and configuration - it only affects the usage of the class but not the structure. So basically we are talking about trade offs in the usage of the class and its maintenance.

If you have an easy time instanatiating your objects from a datasource like you use for generating the classes, then why not do so? If the constructor only takes three easy to remember or easy to look up arguments, why subclass? There's no reason to create so many classes.

Generating the classes on the other hand can turn out to be harder maintenance, as you need to maintain the base class and also the generators if for some reason - and contrary to your expectations - things change.

I can only think of one reason to opt for the subclasses: When it makes your API significantly simpler and your code easier to understand. For example when your class is instantiated very often by the programmer and it's easier for her/him to remember the classname instead of a hard to remember qualifier for the data that is to be fetched from the text file. Or if you absolutely can not fetch the data with a qualifier and the programmer has to lookup or calculate a lot of values to instantiate the class. IMHO that's some sort of convention over configuration then and can really turn out to be an API enhancement - especially if the subclass is the natural place to search for the values if a programmer needs to look them up. But in many cases you should also be able to adjust your data source format in a way that humans can easily interact with it.

Another reason to generate sublasses is when - also contrary to your expectations - you realize that you will need enhanced behaviour on at least some of them.

To be clear, my language (Python) doesn't support interfaces that I'm aware of - some of the other similar questions seemed to get answers recommending that.

That is because dynamically typed language don't need interfaces. Mose use duck typing.