Działania na ułamkach zwykłych - ćwiczenie programowania obiektowego - Python 3.X

Treść zadania:
Zaprogramować obiektowo: program wczytuje ciąg znaków
reprezentujący pewne wyrażenie ułamkowe, na wyjściu
obliczany jest ułamek w postaci nieskracalnej reprezentujący
wartość wczytanego wyrażenia ułamkowego. Dodatkowe wymaganie:
w programie nie wolno używać typów wartości zmiennoprzecinkowych, float i double.
Działanie zawsze zaczyna się nawiasem otwierającym "(" a kończy nawiasem zamykający ")". Kolejność wykonywania operacji uwarunkowana jest zagnieżdżeniem nawiasów.
Wskazówka:
Można użyć algorytmu używającego stosu i obliczającego odwrotną
notację polską wczytanego wyrażenia. Z obliczonej odwrotnej
notacji utworzyć obiekt reprezentujący wczytane wyrażenie
ułamkowe i w utworzonym obiekcie wywołać metodę skracania.


Zadanie jest dobrym przykładem w jaki sposób
ćwiczyć tworzenie programów obiektowych.

Przykładowe wejścia wyjścia:

Wejście:
((1/2)+(1/4))

Wyjście:
6
8

Wejście:
(((((1/4)+(2/3))-((1/4)-(1/6)))*(2/3))/(2/1))

wyjście:
480
1728

Wejście:
((((1/4)-(1/8))*((1/4)-(1/6)))+(1/2))

Wyjście:
784
1536


Kod źródłowy:

class ulamek:
    def __init__(self, counter, denominator):
        self.c = counter
        self.d = denominator
        
class calculator:

# class to count operation on two arguments

    def addition(x, y):
        return (int(x)+int(y))

    def subtraction(x, y):
        return (int(x)-int(y))

    def multiplication(x, y):
        return (int(x)*int(y))

    def division(x, y):
        return (int(x)/int(y))

class fraction(calculator):

# 'A' and 'X' is a counter
# 'B' and 'Y' is a denominator

    def fraction_addition(self, a,b, x,y):
        if b == y:
            return ulamek(calculator.addition(a,x),int(b))
        else:
            return ulamek(calculator.addition(calculator.multiplication(a,y),calculator.multiplication(x,b)),calculator.multiplication(b,y))     
        
    def fraction_subtraction(self, a,b, x,y):
        if b == y:
            return ulamek(calculator.subtraction(a,x),int(b))
        else:
            return ulamek(calculator.subtraction(calculator.multiplication(a,y),calculator.multiplication(x,b)),calculator.multiplication(b,y))          

    def fraction_multiplication(self, a,b, x,y):
        return ulamek(calculator.multiplication(a,x),calculator.multiplication(b,y))

    def fraction_division(self, a,b, x,y):
        return ulamek(calculator.multiplication(a,y),calculator.multiplication(b,x))

def main():
    pass

if __name__ == '__main__':
    main()
    instance = fraction()
    s=input("Enter action: ")
    print(s)

    i=0
    int(i)

    counter=0
    int(counter)

    stack = []
    stackoperator = []
    
    array=list(s)
    
    while (i<len(s)):
        if array[i]=="(":
            counter+=1
        elif array[i]==")":
            counter-=1
            op=stackoperator.pop()
            U2=stack.pop()
            U1=stack.pop()
            if op=="+":
                U3=instance.fraction_addition(U1.c,U1.d,U2.c,U2.d)
            elif op=="-":
                U3=instance.fraction_subtraction(U1.c,U1.d,U2.c,U2.d)
            elif op=="*":
                U3=instance.fraction_multiplication(U1.c,U1.d,U2.c,U2.d)
            else:
                U3=instance.fraction_division(U1.c,U1.d,U2.c,U2.d)
            stack.append(U3)
            
        elif array[i]=="+":
            stackoperator.append(array[i])
        elif array[i]=="-":
            stackoperator.append(array[i])
        elif array[i]=="*":
            stackoperator.append(array[i])
        elif array[i]=="/":
            stackoperator.append(array[i])
        else:
            stack.append(ulamek(int(array[i]),1))
        i=i+1
    cy=stack.pop()
    print(cy.c)
    print(cy.d)