Tweaked identical binary tree

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param a: the root of binary tree a.
    @param b: the root of binary tree b.
    @return: true if they are tweaked identical, or false.
    """
    def isTweakedIdentical(self, a, b):
        if not a and not b:
            return True

        if a and not b:
            return False

        if b and not a:
            return False
        # write your code her

        def inorder_traversal_left(root,res):
            if not root:
                return

            inorder_traversal_left(root.left,res)
            res.append(root.val)
            inorder_traversal_left(root.right,res)
            return

        def inorder_traversal_right(root,res):
            if not root:
                return

            inorder_traversal_right(root.right,res)
            res.append(root.val)
            inorder_traversal_right(root.left,res)
            return

        def preorder(root,res):
            if not root:
                return

            res.append(root.val)
            preorder(root.left,res)
            preorder(root.right,res)
            return

        def same_tweaked_tree(x,y):
            if not x and not y:
                return True

            if x and not y:
                return False

            if y and not x:
                return False

            return same_tweaked_tree(x.left,y.right) and same_tweaked_tree(x.right,y.left)

        a_inorder_left=[]
        b_inorder_left,b_inorder_right=[],[]

        inorder_traversal_left(a,a_inorder_left)
        inorder_traversal_left(b,b_inorder_left)
        inorder_traversal_right(b,b_inorder_right)

        tweaked=False
        print(a_inorder_left)
        print(b_inorder_left)
        print(b_inorder_right)

        if a_inorder_left==b_inorder_left:
            return True
        else:
            if a_inorder_left==b_inorder_right:
                tweaked=True
            else:
                return False

        print(tweaked)
        if not tweaked:
            a_preorder,b_preorder=[],[]
            preorder(a,a_preorder)
            preorder(b,b_preorder)
            return a_preorder==b_preorder
        else:
            print('here')
            return same_tweaked_tree(a,b)