def __new__(cls, cls_name, cls_parents, cls_attrs): logging.info("Detectando aspectos da classe %s" % cls_name) logging.debug("Detectando se e uma classe abstrata ou uma interface") mode = map(lambda cls_parent:cls_parent.__name__, filter(lambda cls_parent: cls_parent.__name__ in ("abstract", "interface"), cls_parents)) # Detect if it's abstract or is interface if mode[1:]: mode = ["interface"] if not mode and cls_name in ("abstract", "interface"): mode = [cls_name] verify = False if not mode: logging.debug("Escaneando parentes para detectar um modo padrao") for key, classes in cls.saved.iteritems(): if filter(lambda cls_parent: cls_parent.__name__ in classes, cls_parents): verify = BaseUtils.findBases(key, cls_parents) verify_mode = key break if mode: logging.debug("Modo detectado: %s" % mode[0]) cls.saved[mode[0]] = cls.saved.get(mode[0], []) + [cls_name] cls_attrs["__init__"] = BaseUtils.getConstructor(mode[0], cls_attrs.get("__init__")) cls_attrs = dict(map(BaseUtils.applyAll, cls_attrs.iteritems())) cls_attrs["__cls_implemented__"] = False # Just a flag do indicate that no verified classes need to verificate in inheritance elif verify: logging.debug("Verificando como %s" % verify_mode) classAttrs = {} map(lambda child_cls: classAttrs.update(child_cls.__dict__), verify) classAttrs["__init__"] = classAttrs["__init__"].__oldconstructor__ if not classAttrs["__init__"] and not cls_attrs.has_key("__init__"): cls_attrs["__init__"] = BaseUtils.getEmptyConstructor() elif not cls_attrs.has_key("__init__") and verify_mode == "abstract": cls_attrs["__init__"] = classAttrs["__init__"] cls_attrs = dict(map(BaseUtils.applyAll, cls_attrs.iteritems())) map(functools.partial(BaseUtils.verifyAttr, verify_mode, cls_name, classAttrs), cls_attrs.iteritems()) methodsNotEncountered = filter(lambda attr: attr != "__metaclass__" and callable(classAttrs[attr]) and not getattr(classAttrs[attr], "__implemented__", verify_mode == "abstract") and attr not in cls_attrs, classAttrs.iterkeys()) for method_not_encountered in methodsNotEncountered: raise NotImplementedError("The method '" + method_not_encountered + "' was not encountered in the class '" + cls_name + "'") cls.saved[verify_mode] = cls.saved.get(verify_mode, []) + [cls_name] # Add the reference to allow the subclasses of this class to be scanned cls_attrs["__cls_implemented__"] = True # Just a flag do indicate that verified classes don't need to repeat the verification in inheritance logging.debug("Criando classe") obj = super(AbstractInterfaceType, cls).__new__(cls, cls_name, cls_parents, cls_attrs) # Scan static attributes cls_static_attrs = list((attr_name, getattr(obj, attr_name)) for attr_name in dir(obj)) # Get Only static methods cls_static_methods = dict((attr for attr in cls_static_attrs if callable(attr[1]) and not inspect.ismethod(attr[1]) and inspect.isfunction(attr[1]))) map(BaseUtils.applyAll, cls_static_methods.iteritems()) if not mode and verify: # It's to verify? classStaticAttrs = {} map(lambda child_cls: classStaticAttrs.update(dict((attr_name, getattr(child_cls, attr_name)) for attr_name in dir(child_cls))), verify) # Get only static methods classStaticAttrs = dict((attr for attr in classStaticAttrs.iteritems() if callable(attr[1]) and not inspect.ismethod(attr[1]) and inspect.isfunction(attr[1]))) classStaticAttrs_items = classStaticAttrs.items() cls_static_methods = dict((attr for attr in cls_static_methods.iteritems() if attr not in classStaticAttrs_items)) map(functools.partial(BaseUtils.verifyAttr, verify_mode, cls_name, classStaticAttrs), cls_static_methods.iteritems()) methodsNotEncountered = filter(lambda attr: attr != "__metaclass__" and callable(classStaticAttrs[attr]) and not getattr(classStaticAttrs[attr], "__implemented__", verify_mode == "abstract") and attr not in cls_static_methods, classStaticAttrs.iterkeys()) for method_not_encountered in methodsNotEncountered: raise NotImplementedError("The static method '" + method_not_encountered + "' was not encountered in the class '" + cls_name + "'") # setattr(__builtin__, cls_name, obj) return obj
def applyToClass(name, attrs): logging.debug("Escaneando classe %s" % name) for key, val in attrs.iteritems(): if key.startswith("__"): continue if inspect.isclass(val) and "enum" in val.__bases__: applyToClass(".".join([name, key]), val.__dict__) else: logging.debug("Alterando atributo %s para ENUM" % key) attrs[key] = EnumVal(name, key) attrs["__init__"] = BaseUtils.getConstructor("enum") return attrs
def __repr__(self): cls_name = self.__name__ cls_parents = self.__bases__ mode = map(lambda cls_parent:cls_parent.__name__, filter(lambda cls_parent: cls_parent.__name__ in ("abstract", "interface"), cls_parents)) if mode[1:]: mode = ["interface"] if not mode and cls_name in ("abstract", "interface"): mode = [cls_name] if not mode: for key, classes in AbstractInterfaceType.saved.iteritems(): if filter(lambda cls_parent: cls_parent.__name__ in classes, cls_parents): verify = BaseUtils.findBases(key, cls_parents) verify_mode = key break return "<Implementation of the %s %s with the name '%s'>" % (verify_mode, ", ".join(map(lambda cls:"'" + cls.__name__ + "'", verify)), cls_name) return "<%s '%s'>" % (mode[0], cls_name)