Megoldas a metaclasses

Ujra vissza az elozo problemahoz. A metaclassok tulajdonkeppen olyan osztalyok amiknek a peldanyai is osztalyok. Ez igy elsore lehet furcsan hangzik mert az ember ugy tanulta hogy az osztalyok peldanyai az objectek. Objectet az ember ugy csinal hogy van egy osztalya ami sablonkent mukodik es az alapjan csinal belole peldanyt. Ugyanazt meg lehet tenni osztallyal is, azaz egy olyan masfajta osztaly kell ami maga is osztalyt ir le. Ez a masfajta osztaly a metaclass. Pythonban a legnyilvanvalobb, beepitett metaosztaly a type. De ilyen a types.ClassType is. Ez elobbi a beeptitett osztalyok metaclassa, az utobbi pedig a user altal gyarott osztalyoke. Pythonban maguk az osztalyok is objectkent vannak megvalositva, ugyanugy (legalabbis az en problemam szempontjabol) jonnek letre (egy metaclass peldanyaikent), mint a normal objectek. Ez pedig megoldast jelent szamomra, mert nincs mas dolgom mint csinalni egy uj metaosztalyt, aminek a konstruktoraba elrejtem az interface ellenorzo kodomat. Ebbol a metaosztalybol csinalni egy uj peldanyt, azaz egy normal osztalyt. Ez lesz az Interface osztaly aminek a metaosztalya az InterfaceType. Az Interface mar egy teljesen normalis osztaly, ebbol leszarmatathatok barmilyen interfacet. pl.:

class ITest( Interface ):
    def test(self, t): pass

Mivel az Interface osztaly az InterfaceType konstruktorat orokolte (metaosztalyoknak is van konstruktoruk ami akkor fut le ha peldanyt hozunk letre belole, azaz normal osztalyt a metaosztalybol), az ITest pedig az ovet. Igy az ITest osztaly megkrealasakor, le fog futni a metaosztalyomban levo ellenorzo kod. Hangsulyozom hogy osztaly letrehozasakor, nem osztaly peldanyositasakor. Ezutan ezt az interfacet "implementalom", amihez ugyanugy az oroklest hasznalom.

class Test( ITest ):
    def test(self, t):
        return t

A Test osztaly letrehozasakor szinten lefut az ellenorzes. Mi is van ebben az ellenorzesbe. Eloszor is lekerdezi az aktualis osztaly metodusait. Jelen esetben a Test krealasakor ez a 'test' metodus. Lekerdezi az osztaly direkt oseit. Ha ennek az osnek az ose Interface osztaly akkor o maga egy Interface. ITest jelen esetben. Igy el tudom donteni hogy a Test osei kozul melyik az interface mert nem biztos hogy csak ITestbol fog szarmazni, lehet ott mas nem interface osztaly is. Tehat megvannak az implementalando interfacek (ITest vagy Interface osztaly letrehozasakor nem fog ilyet talalni ekkor nem is ellenoriz semmit). Az interfacek metodusait egyenkent lekerdezem, jelen esetben megkapom az Itest.test(self, t)-t, es megnezem hogy ez egyenlo-e (marmint 2 fuggveny referencia) az aktualis osztaly a Test, ugyanilyen nevu (mert hat biztos hogy van neki ilyen hiszen orokolte, kerdes hogy a user feluldefinialta-e) metodusaval. Ha a 2 referencia megegyezik akkor csak sima oroklesrol van szo, ha kulonbozo akkor felul lett definialva, azaz a user kozvetlenul beleirta a kodba, tehat implementalta. Ezutan leellenorozm meg a fuggveny parametereinek a szamat is, ha nem stimemel ugyanugy assert errorozik (azert assert, mert az letilthato egy parancsosoros parameterrel ha pl release verzional nem akarjuk ellenorizgetni). Szoval ha en azt mondom hogy class Test( ITest, Base1, Base2 ), es az ITest interfacebol szarmazik, a Base1/2 pedig normal osztaly, akkor az ITestben levo metodusokat koteles vagyok feluldefinialni.

Es akkor jojjon a kod:

from types import MethodType

def getMethods( clz ):
    return [i for i in dir(clz) if type(getattr(clz, i)) == MethodType]

class InterfaceType(type):

    def __new__(cls, name, bases, dct):
        return type.__new__(cls, name, bases, dct)

    def __init__(cls, name, bases, dct):
        super(InterfaceType, cls).__init__(name, bases, dct)

        for b in bases:
            if b.__base__.__name__ == 'Interface':
                imet = getMethods( b )
                for m in imet:
                    assert getattr( cls, m ) != getattr( b, m ),                        'WARNING: method %s not implemented in %s' % ( m, cls.__name__ )

                    assert getattr( cls, m ).func_code.co_argcount == getattr( b, m ).func_code.co_argcount,                        'WARNING: method %s not correctly implemented in %s (parameter mismatch)' % ( m, cls.__name__ )

Interface = InterfaceType('Interface', (), {})

Mivel metaclassrol van szo lathato hogy konstruktorban nem self, hanem cls, azaz metaosztaly peldanyra mutato referencia van. A __new__ az __init__ elott hivodik meg es az uj osztaly peldanyaval ( ami most szinten osztaly mivel metaclassbol hozza letre ) ter vissza ('type' osztaly factorykent mukodik). Elofordulhat hogy ugy jon letre az osztaly hogy az __init__ nem hivodik meg pl picklevel serializaljuk be, ilyenkor az ellenorzes sem fog lefutni (normal osztaly betolteskor szerintem le kell mindig). De a 2 cls parameter nem ugyanaz a 2 fuggvenyben. A __new__ban a self-el analog a metaosztaly sajat referencia van, mig a konstruktorban az aktualis metaosztaly peldany, azaz normal osztalyra mutato referencia. A for loopban a direkt ososztalyokbol kivalasztjuk azokat akiknek az ose az Interface, es ezutan kovtkezik a metodusok osszehasonlitasa. Az utolso sor nagyon fontos, Interface = InterfaceType('Interface', (), {}), itt hozok letre az InterfaceType metaosztalybol egy peldanyt, azaz egy normal Interface osztalyt.

Itt pedig a test kod

from interface import Interface

class ITest( Interface ):
    def test(self, t): pass

class Cloneable( Interface ):
    def clone(self): pass

class Test( ITest, Cloneable ):
    def lofasz(self):
        return t

    def test(self, t):
        return t

    def clone(self):
        print 'clone'

class Test2( Test):
    pass

A modszer meg erosen kiserleti, tesztelest igenyel, de elsore nem latok olyan problemakat mint az elozo kettonel.