Notice that Peter's approach also works without inheritance:
registries = {}
@property
def per_class(self):
cls = type(self)
try:
return registries[cls]
except KeyError:
result = registries[cls] = []
return result
class A(object): per_class=per_class
class B(object): per_class=per_class
assert A().per_class is A().per_class
assert B().per_class is B().per_class
assert A().per_class is not B().per_class
(you can also put the per_class property in a module and import it
with
class A(object): from module import per_class).
There is no need to use inheritance if you only need one method.
Notice also that if you
are working with a complex third party framework (say Django) that may
use metaclasses
or strange tricks (such as __slots__) the safer way is to avoid both
inheritance and metaclasses.
HTH,
Michele
Hi Michele, thanks for your contributions. Actually the Petter
proposal it's working for me (AFAIK). I think because my base class is
an abstract class. In particular my adaptation of his proposal (with
the rest of the current BaseService class) is:
from django.db import models
from django.contrib.contenttypes import generic
class BaseService(models.Model):
class Meta:
abstract = True
_service_registry = []
_plugin_registry = {}
@classmethod
def plugin_register(cls, str):
# Per subclass register
try: cls._plugin_registry[cls].append(str)
except KeyError: cls._plugin_registry[cls] = []
@classmethod
def get_plugin_registred(cls):
# Per subclass register
try:
return cls._plugin_registry[cls]
except KeyError:
result = cls._plugin_registry[cls] = []
return result
@property
def extentions_attributes(self):
attributes = []
for model in _plugin_registry:
for attribute in model.get_attributes(self):
attributes.append(attribute[0])
return attributes
@classmethod
def service_register(cls):
cls._service_registry.append(cls)
@classmethod
def get_service_registred(cls):
return cls._service_registry
@property
def attributes(self):
return []
IMHO Django handles very well inheritance, and subclassing is their
major method in order to use the framework. I completely agree with
metaclasses should be avoided when you're working with frameworks
BTW, is there any alternative to the inheritance pattern in order to
provide this set of methods for multiple classes? I'm pretty new in
OOP
Thanks!