Bracket balancing algorithm doesn't detect imbalanced brackets

The code takes in any combination of brackets and checks if they are balanced or not. If they are balanced it should output success; if they aren't balanced it should output the index (starting at index 1) where the brackets are not balanced. Example:

Input: ())
Output: 3
\\
Input: ()
Output: Success

The code always displays "Success" regardless of it being balanced or not. Instead i get this:

Input: ())
Output: Success

import sys

def Match(self, c):
    if self == '[' and c == ']':
       return True
    if self == '{' and c == '}':
       return True
    if self == '(' and c == ')':
       return True
    else:    
       return False

if __name__ == "__main__":
    text = sys.stdin.read()
    char_code = 0
    opening_brackets_stack = []
    for i, next in enumerate(text):
        if next == '(' or next == '[' or next == '{':
             char_code += 1
             opening_brackets_stack.append(next)
             stack_pop = opening_brackets_stack.pop()

        if next == ')' or next == ']' or next == '}':
             char_code += 1
             if not Match(stack_pop, next):
                 print(char_code)
        else:
            char_code += 1
    print ('Success')

Your code is printing "Success" because you've told it that after it finishes it should always print success

if __name__ == "__main__":
    # A bunch of stuff unrelated to program flow...
    print ('Success')

You probably only want success if you've reached the end of your text with nothing in the queue.

if __name__ == "__main__":
    text = sys.stdin.read()
    char_code = 0
    opening_brackets_stack = []
    for i, next in enumerate(text):
        if next == '(' or next == '[' or next == '{':
             char_code += 1
             opening_brackets_stack.append(next)
             stack_pop = opening_brackets_stack.pop()

        if next == ')' or next == ']' or next == '}':
             char_code += 1
             if not Match(stack_pop, next):
                 print(char_code)
        else:
            char_code += 1
    if not opening_brackets_stack:  # <-- new line
        print ('Success')

Except this won't solve your problem either, since you've never properly checked if you have an unmatched closing bracket, only an unmatched opening bracket. Consider this, instead:

# this will let us check for an expected closing bracket more easily
opening_brackets = "([{"
closing_brackets = ")]}"
mapping = dict(zip(opening_brackets, closing_brackets))

stack = []
for i, ch in enumerate(text):
    if ch in opening_brackets:
        # throw the closing bracket on the stack
        matching_closer = mapping[ch]
        stack.append(matching_closer)
    elif ch == stack[-1]:
        # if the character closes the last-opened bracket
        stack.pop()  # pop it off
    elif ch in closing_brackets:
        # this is an unmatched closing bracket, making the brackets
        # imbalanced in this expression
        print("FAILED")
        sys.exit(1)  # closes the program immediately with a retcode of 1
    else:
        # not a bracket, continue as normal
        # this is technically a NOP and everything from the `else` can be
        # omitted, but I think this looks more obvious to the reader.
        continue
if not stack:  # empty stack means matched brackets!
    print("SUCCESS")
else:
    print("FAILED")