Vindicar

Ну что, ошибка правильно тебе говорит.

def __init__(self, replaybtn):
        self.replaybtn = replaybtn

Ты говоришь, что конструктор твоего класса Dinobot принимает один параметр, replaybtn.
А ты ему потом передаёшь два параметра: (470, 440), (202, 442)

if call.data == 'apple' or 'melon':    #Вот в этом месте проблема

Ещё один ботописатель с этой проблемой. Вот откуда такое упорное желание дословно переводить с русского на питон?

Правильно:
if call.data in ('apple', 'melon'):
Ну или так:
if call.data == 'apple' or call.data == 'melon':

То, что ты написал, расшифровывается как
if (call.data == 'apple') or ('melon' != ''):
что эквивалентно
if (call.data == 'apple') or True:
А x or True всегда даст True, так же как x and False всегда даст False.
Так что получается в итоге
if True:

Учи основы языка - потом уже берись за ботов.

Тупой способ: использовать eval(), но это очень рискованно! Если данные приходят извни, атакующий может вписать туда почти любой питоновский код. Потом не плачь, что тебя не предупреждали.

Умный способ, на примере (-5 * 3) - 2:
1. Разбить строку на осмысленные токены : число, оператор и т.п. Для каждого токена хранить его тип и значение. Получим список в духе:

[('parenthesis', '('), ('operator', '-'), ('number', '5'), ('operator', '*'), ('number', '3'), ('parenthesis', ')'), ('operator', '-'), ('number', '2') ]

Тут ушли все пробелы.
2. Подправить унарные операторы. Операторы "+" и "-", следующие за началом строки, открывающей скобкой или другим оператором, являются унарными (с одним аргументом), а не бинарными (с двумя). Их стоит обозначить по другому, чтобы не путать. Получим такое (смотри на второй токен):

[('parenthesis', '('), ('operator', 'unary-'), ('number', '5'), ('operator', '*'), ('number', '3'), ('parenthesis', ')'), ('operator', '-'), ('number', '2') ]

3. Преобразовать из инфиксной нотации (2 + 3) в постфиксную (2 3 +). Для этого есть железнодорожный алгоритм Дейкстры, он гуглится. В постфиксной нотации всё решается куда проще, так как ей не нужны скобки. Наш пример запишется как 5 unary- 3 * 2 -

[('number', '5'), ('operator', 'unary-'), ('number', '3'), ('operator', '*'),  ('number', '2'), ('operator', '-')]

4. Решить пример. Алгоритм очень простой. У нас есть список аргументов, поначалу он пуст. Идём по списку токенов (в постфиксной нотации):
а. Если токен - число, поместить его в конец списка аргументов, перейти к следующему токену.
б. Если токен - унарный оператор, взять и удалить последний элемент из списка, применить к этому элементу оператор, результат добавить в конец списка.
в. Если токен - бинарный оператор, взять и удалить последние 2 элемента из списка, применить к ним оператор (не перепутай порядок аргументов!), результат добавить в конец списка.
Всё! Когда токены кончатся, у тебя в списке аргументов должно быть ровно одно число - это и будет ответ.
На нашем примере:

[('number', '5'), ('operator', 'unary-'), ('number', '3'), ('operator', '*'),  ('number', '2'), ('operator', '-')]

1. Число "5": список аргументов [ 5 ]
2. Унарный минус: берем 5 из списка, применяем оператор, кладем результат назад. Список аргументов [ -5 ]
3. Число "3": список аргументов [ -5, 3 ]
4. Оператор *: берем -5 и 3 из списка, применяем оператор, кладём результат назад. Список аргументов [ -15 ]
5. Число "2": список аргументов [ -15, 2 ]
6. Бинарный минус: берем -15 и 2 из списка, применяем оператор, кладём результат назад. Список аргументов [ -17 ]
Токены закончились, в списке одно число -17. Это ответ.

Литерал означает, что данная переменная/параметр всегда имеет одно из перечисленных значений. Так что...

other_player_mark = 'cross' if mark == 'zero' else 'zero'

Не, ты, конечно можешь извратиться...

import typing as t

Mark = t.Literal['cross', 'zero']

class TicTacToePlayer:
    def __init__(self,
                 mark: Mark,
                 field: TicTacToeField
                 ):
        self.cells = []
        self.mark = mark
        self.field = field
    
    def opposite(self, mark: Mark) -> Mark:
        values = t.get_args(Mark)
        idx = values.index(mark)
        next_idx = int(not idx)
        return t.cast(Mark, values[next_idx])

но лучше не надо!

recieved = await reader.read(2048)
Ты читаешь 2КБ. И всё.
Проблема в том, что размер пакета при передаче по сети ограничен. Хоть гигабайт отправь, приходить будет порциями. И вообще, отправитель (или промежуточное сетевое оборудование) может данные хоть по байту нарезать, ты это не контролируешь.
Поэтому обязательно надо предусматривать какой-то способ определить конце передачи, и повторять чтение в цикле, поке конец не достигнут. Основных способов два.
1. Передавать сначала размер данных в байтах (фиксированным размером - например, как 4байтовое целое), потом сами данные. Читаешь размер, разбираешь его в целое число, читаешь данные, пока не накопится желаемое число байт.
2. После переданных данных передавать условную последовательность "конец передачи". Тогда читаешь данные, пока эта последовательность не встретится.
У тебя данные бинарные, первый способ сработает лучше.

Технически - да, во втором быстрее.
Но разница будет микросекундная. Обращение к словарю - быстрая операция, по сравнению даже с парсингом JSON, а он, в свою очередь - быстр по сравнению с сетью.

Если ты хочешь при любом действии пользователя убедиться, что он в базе, то тебе нужен не просто INSERT, а INSERT ON CONFLICT IGNORE или INSERT ON CONFLICT UPDATE. Если тебе требуется что-то обновлять (например, хранить для пользователя момент последнего обращения к боту), то нужен второй. Если не требуется, то лучше первый.