Palindrome using Stack in Python

I am trying to implement palindrome using stack but I am stuck with the code below. While I should get 'True', I am getting 'False'. Can you please help me through?

from Stack import Stack
import copy

def display(data):
    original= Stack()
    reverse= Stack()
    for i in range(len(data)):
        original.push(data[i])
        
    dat=copy.deepcopy( original)
#    print(hex(id(dat)))
#    print(hex(id(original)))
    
    for i in range(len(data)):
        a= original.pop()
        reverse.push(a)
#    original.disp()
    reverse.disp() #disp() shows elements in list form
    dat.disp()
    if dat == reverse:
        return True
        
    else:
        return False
        
print(display('racecar'))

If you push the letters from the first half of a word onto the stack, you should be able to compare them to rest of the word letter by letter as you pop them off the stack. If they all match you have a palindrome. There's no need to manually reverse the list (and that kind of defeats the point of using a stack) or make copies. Both hurt the efficiency. The trick is distinguishing words with odd lengths from even lengths, because you don't need to compare the middle letter in odd-length words

Since you didn't provide a stack implementation, I'll just use a list, but you should be able to see how it works:

def pali(s):
    stack = []
    mid = len(s)//2
    
    # push first half of the word onto stack
    for c in s[:mid]:
        stack.append(c)
 
    # adjust mid for odd length words
    if len(s) % 2: 
        mid+=1

    # look at rest of the word while popping off the stack
    for c in s[mid:]:
        if stack.pop() != c:
            return False

    return True
      
print(pali("hello")) # False
print(pali("madamimadam")) # True

Given that @MarkMeyer's answer is the correct way to proceed if you want to make use of stacks, if your input is actually a Python sequence (e.g. a list, tuple, str, etc.) a much more compact and efficient way of checking for palindrome is by using slicing:

def is_palindrome(seq):
    n = len(seq)
    m = n // 2
    q = m + n % 2 - 1
    return seq[:m] == seq[:q:-1]


print(is_palindrome('ciao'))
# False
print(is_palindrome('aboba'))
# True
print(is_palindrome('abooba'))
# True

class Stack_structure:
   def __init__(self):
      self.items = []

   def check_empty(self):
      return self.items == []

   def push_val(self, data):
     self.items.append(data)

   def pop_val(self):
      return self.items.pop()

my_instance = Stack_structure()
text_input = input('Enter the string... ')

for character in text_input:
   my_instance.push_val(character)

reversed_text = ''
while not my_instance.check_empty():
   reversed_text = reversed_text + my_instance.pop_val()

if text_input == reversed_text:
   return True
else:
return False