Doubly Linked in py

#node class goes in Node.py

class Node:

    def __init__(self, a_data):
        self.prev = None
        self.next = None
        self.data = a_data

    def __str__(self):
        return str(self.data)

#unit tests go in their own file of any name

import unittest
import Node
import Doubly_Linked

class DoublyTest(unittest.TestCase):

    def test_Node(self):
        test_case1 = Node.Node(5)
        self.assertEqual(test_case1.next, None)
        self.assertEqual(test_case1.prev, None)
        self.assertEqual(test_case1.data, 5)

    def test_DoublyPushPrint(self):
        test_case1 = Doubly_Linked.Doubly_Linked()
        test_case1.push(5)
        test_case1.push(4)
        self.assertEqual(str(test_case1),"5 4")

    def test_Doublepop(self):
        test_case3 = Doubly_Linked.Doubly_Linked()
        test_case3.push(5)
        test_case3.push(4)
        self.assertEqual(test_case3.pop(), 4)
        self.assertEqual(test_case3.pop(), 5)

    def test_DoublyEmpty(self):
        test_case2 = Doubly_Linked.Doubly_Linked()
        self.assertRaises(Exception, test_case2.pop)

    def test_DoubleyTraverse(self):
        test_case4 = Doubly_Linked.Doubly_Linked()
        self.assertRaises(Exception, test_case4.get, 4)
        test_case4.push(1)
        self.assertRaises(Exception, test_case4.get, 2)
        test_case4.push(2)
        test_case4.push(3)
        test_case4.push(4)
        self.assertEqual(test_case4.get(4),4)
        self.assertRaises(Exception, test_case4.get, 0)
        self.assertRaises(Exception, test_case4.get, -1)

    def test_DoubleyDelete(self):
        test_case5 = Doubly_Linked.Doubly_Linked()
        self.assertRaises(Exception, test_case5.remove,-1)
        self.assertRaises(Exception, test_case5.remove, 1)
        test_case5.push(1)
        test_case5.push(2)
        test_case5.push(3)
        test_case5.remove(3)
        self.assertEqual(test_case5.size,2)
        self.assertEqual(test_case5.pop(),2)


if __name__ == '__main__':
    unittest.main()

#Doubly linked class goes in Doubly_linked.py

import Node

class Doubly_Linked:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    def get(self,location):
        if location <= 0:
            raise Exception("Out of bounds")
        if self.size == 0:
            raise Exception("List is empty")
        elif location > self.size:
            raise Exception("Out of bounds")

        if self.size == 1:
            result = self.head.data

        else:
            current_node = self.head
            for i in range(location-1):
                current_node = current_node.next
            result = current_node.data
        return result

    def remove(self,location):
        if location < 0:
            raise Exception("Out of bounds")
        if location > self.size:
            raise Exception("Out of bounds")
        if self.size == 0:
            raise Exception("Empty list")
        if self.size == 1:
            self.size = 0
            self.head = None
        else:
            current_node = self.head
            for i in range(location-1):
                current_node = current_node.next
            current_node.next.prev = current_node.prev
            current_node.prev.next = current_node.next
            if current_node == self.tail:
                self.tail = self.head.prev
            if current_node == self.head:
                self.head = current_node.next
            current_node = None
            self.size -= 1


    def pop(self):
        if self.size == 0:
            raise Exception("List is empty")
        self.tail.prev.next = self.head
        self.head.next = self.tail.prev
        result = self.tail.data
        self.tail = self.tail.prev
        self.size -= 1
        return result

    def push(self, a_data):
        if self.size == 0: #case for an empty list getting its first data members
            self.head = Node.Node(a_data)

        elif self.tail == None: #case for a list with a head but no tail
            self.tail = Node.Node(a_data)
            self.tail.next = self.head
            self.tail.prev = self.head
            self.head.next = self.tail
            self.head.prev = self.tail

        else:
            new_node = Node.Node(a_data) #all other cases
            new_node.prev = self.tail
            new_node.next = self.head
            self.head.prev = new_node
            self.tail.next = new_node
            self.tail = new_node

        self.size += 1

    def __str__(self):
        result = ""
        current_node = self.head
        while current_node != self.tail:
            result += str(current_node) + " "
            current_node = current_node.next
        result += str(self.tail)
        return result