So I am stuck on a problem. I have a class which I want to use to create
another class without having to go through the boiler plate of subclassing.
Specifically because the subclass needs to have certain class attributes
and I would like to control how those are passed to provide defaults and
such. What I have working right now is
class Foo():
@classmethod
def method_a(cls): print(cls.name)
Bar = type('Bar', (Foo,), {'name': 'test1'})
Bar.method_a()
This is sort of fine but the user needs to know how to call type and
include all the base classes etc.
I could just wrap the type call in a function like below
def BarMaker(name):
return type('Bar', (Foo,), {'name': name})
But then if the user needs to actually subclass Foo, to add additional
methods that is more difficult. Of course those methods could be added as
part of the third argument to types but that just doesn't feel very Python.
This is all complicated by the fact that I am trying to avoid actually
instancating any of these classes because their purpose is to be passed off
to another framework to be executed. In real life most of the classes would
fail to instantiate because they are relying on pieces of the framework
that won't be up and running when this setup is happening.
The solution I am hoping for is something like
Foo(name, **kwds) -> Returns new class type of name
For example
test = Foo('test')
So that then optionally a user could do
class UserClass(Foo):
def new_method():
pass
bar = UserClass('Bar')
Or something similar. Since I have a working example with type I feel like
there should be a way to do this with the normal class structure but I am
at a loss for how I have messed with the __new__ and __prepare__ methods
and I can't seem to make anything work and the examples of meta classes
don't clearly show how to convert my type example to a class structure.
Is what I want to do possible?
Chris
--
https://mail.python.org/mailman/listinfo/python-list
