Simulation.py | Python Fiddle

__metaclass__ = type

class LogicGate():

def __init__(self, name):
        self.label = name
        self.output = None

def getLabel(self):
        return self.label

def getoutput(self):
        self.output = self.performGateLogic()
        return self.output

class BinaryGate(LogicGate):

def __init__(self, name):
        super(BinaryGate, self).__init__(name)
        self.pinA = None
        self.pinB = None

def getPinA(self):
        if self.pinA is None:

return int(input('Enter Pin A input for gate ' + self.getLabel()
                             + '-->'))
        elif type(self.pinA) is int:
            return self.pinA
        else:
            #            print self.pinA
            #            print self.pinA.getFrom()
            return self.pinA.getFrom().getoutput()

def getPinB(self):
        if self.pinB is None:
            return int(input('Enter Pin B input for gate ' + self.getLabel()
                             + '-->'))
        elif type(self.pinB) is int:
            return self.pinB
        else:
            return self.pinB.getFrom().getoutput()

def setNextPin(self, source):
       # print source
        if self.pinA is None:
            self.pinA = source
        else:
            if self.pinB is None:
                self.pinB = source
            else:
                raise RuntimeError('Error: No EMPTY PINS for %s' % self.label)

class UnaryGate(LogicGate):

def __init__(self, name):
        super(UnaryGate, self).__init__(name)
        self.pin = None

def getPin(self):
        if self.pin is None:
            return int(input('Enter Pin input for gate ' + self.getLabel()
                             + '-->'))
        else:
            return self.pin.getFrom().getoutput()

def setNextPin(self, source):
        if self.pin is None:
            self.pin = source
        elif type(self.pin) is int:
            return self.pin
        else:
            raise RuntimeError('Error: No Empty pins for %s' % self.label)

class AndGate(BinaryGate):

def __init__(self, n):
        super(AndGate, self).__init__(n)

def performGateLogic(self):
        a = self.getPinA()
        b = self.getPinB()

if a * b == 1:
            return 1
        else:
            return 0

class NANDGate(AndGate):

def performGateLogic(self):
        if super(NANDGate, self).performGateLogic():
            return 0
        else:
            return 1

class OrGate(BinaryGate):

def __init__(self, n):
        super(OrGate, self).__init__(n)

def performGateLogic(self):
        a = self.getPinA()
        b = self.getPinB()

if a + b == 0:
            return 0
        else:
            return 1

class NORGate(OrGate):

def performGateLogic(self):
        if super(NORGate, self).performGateLogic():
            return 0
        else:
            return 1

class XORGate(OrGate):

def performGateLogic(self):
        a = self.getPinA()
        b = self.getPinB()
        if a == b:
            return 0
        else:
            return 1

class Notgate(UnaryGate):

def __init__(self, n):
        super(Notgate, self).__init__(n)

def performGateLogic(self):
        a = self.getPin()
        if a == 1:
            return 0
        else:
            return 1

class Connector:

def __init__(self, fgata, tgate):
        self.frontgate = fgata
        self.togate = tgate

tgate.setNextPin(self)

def getFrom(self):
        return self.frontgate

def getTo(self):
        return self.togate

class OneBitFullAdder(BinaryGate):

def __init__(self, name, cin=None):
        self.label = name
        self.g1 = XORGate('XOR1')
        self.g2 = XORGate('XOR2')
        self.g3 = AndGate('AND1')
        self.g4 = AndGate('AND2')
        self.g5 = OrGate('OR1')
        self.c1 = Connector(self.g1, self.g2)
        self.c2 = Connector(self.g1, self.g3)
        self.c3 = Connector(self.g3, self.g5)
        self.c4 = Connector(self.g4, self.g5)
        self.pinA = None
        self.pinB = None
        self.cin = cin
        self.cout = None
        self.s = None

def getcin(self):
        if self.cin is None:
            return int(input('Enter cin input for gate ' + self.getLabel()
                             + '-->'))
        else:
            return self.cin

def performSum(self):
        a = self.getPinA()
        b = self.getPinB()
        c = self.getcin()
        self.g1.pinA = a
        self.g1.pinB = b
        self.g2.pinB = c
        self.g3.pinB = c
        self.g4.pinA = a
        self.g4.pinB = b

self.cout = self.g5.getoutput()
        self.s = self.g2.getoutput()
        return(self.cout, self.s)

class EightBitAdder:

def __init__(self):
        self.adderlist = []
        for i in range(8):
            self.adderlist.append(OneBitFullAdder('add%d' % i))
        print 'all adder made'
        self.adderlist[0].cin = 0

def performSum(self, A, B):
        listA = list(str(A))
        listB = list(str(B))
#        print listA, listB

for i in range(8):
            self.adderlist[i].pinA = int(listA[7 - i])

self.adderlist[i].pinB = int(listB[7 - i])

self.result = []
        for i in range(8):
            self.adderlist[i].performSum()
            if i < 7:
                self.adderlist[i + 1].cin = self.adderlist[i].cout
        self.result.append(self.adderlist[7].cout)
        for i in range(7, -1, -1):
            self.result.append(self.adderlist[i].s)

return self.result

def main():
    add1 = EightBitAdder()
    print add1.performSum('11110111', '10000000')

main()

Python Fiddle

Python Cloud IDE