Implementing a LinkedList in Python - Is leetcode wrong?

Question

I'm working on this problem: https://leetcode.com/explore/learn/card/linked-list/209/singly-linked-list/1290/

and leetcode is telling me that my code is throwing a runtime error. The input it's trying to make my code run is this:

["MyLinkedList","addAtHead","deleteAtIndex","addAtHead","addAtHead","addAtHead","addAtHead","addAtHead","addAtTail","get","deleteAtIndex","deleteAtIndex"]
[[],[2],[1],[2],[7],[3],[2],[5],[5],[5],[6],[4]]

Where the first array contains the function name and the second contains the function parameters. E.g. the second element adds a 2 at the head of the linkedlist. My question is that how would it be OK to be deleting the element at index 1 when there is only one element in the linkedlist? Is there some special thing about linked lists that I should know or is the input case incorrect. Below is my code for reference.

class SinglyLinkedList():
    def __init__(self):
        self.head = None
        self.tail = None
        self.length = 0
    
    def get(self, index):
        if index<0 or index>self.length: raise AssertionError("get index must be in bounds")

        node = self.head
        for _ in range(index):
            node = node.next
        return node
    
    def addAtHead(self, val):
        node = SinglyListNode(val)
        if self.length==0:
            self.head = node
            self.tail = self.head
        else:
            node.next = self.head
            self.head = node
        self.length+=1
    
    def addAtTail(self, val):
        node = SinglyListNode(val)
        if self.length==0:
            self.tail = node
            self.head = self.tail
        else:
            self.tail.next = node
            self.tail = node
        self.length+=1
    
    def addAtIndex(self, index, val):
        if index<0 or index>self.length:
            raise AssertionError(f"index at which to add ({index}) is out of bounds")
        
        if index==0:
            return self.addAtHead(val)
        if index==self.length:
            return self.addAtTail(val)

        newNode = SinglyListNode(val)

        node = self.head
        for _ in range(index-1):
            node = node.next
        newNode.next = node.next
        node.next = newNode

        self.length+=1

    
    def deleteAtIndex(self, index):
        if index<0 or index>self.length:
            raise AssertionError(f"index at which to add ({index}) is out of bounds")
        
        if index==0:
            self.head = self.head.next
        elif index==self.length-1:
            self.tail=self.get(self.length-2)
        else:
            node = self.head
            for _ in range(index-1):
                node = node.next
            node.next = node.next.next
        self.length-=1

    
    def __str__(self):
        res = "["
        node = self.head
        for _ in range(self.length-1):
            res += str(node)+","
            node = node.next
        res += str(node)+f"] ({self.length})"
        return res

Answer 1

From https://leetcode.com/problems/design-linked-list/

void deleteAtIndex(int index) Delete the index^th node in the linked list, if the index is valid.

Looks like the delete needs to be done only when the index is valid. Your code needs to handle the case when the index is invalid.