Vindicar

Тупой способ: использовать 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. Если тебе требуется что-то обновлять (например, хранить для пользователя момент последнего обращения к боту), то нужен второй. Если не требуется, то лучше первый.

Гуглить пробовал? На первой странице выдачи этот ответ на StackOverflow.
Если коротко:

Зависит от установленных на компе голосовых движков. Проверь доступные движки так:

import pyttsx3

engine = pyttsx3.init()
for voice in engine.getProperty('voices'):
    print(voice)

Ищи голоса, у которых упомянут русский язык. Если нет - гугли, как их ставить.

Определившись с голосом, пропиши его id в скрипте, например

# тут id голоса, который ты выбрал
voice_id = "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech\Voices\Tokens\MSTTS_V110_trTR_Tolga"
engine = pyttsx3.init()
engine.setProperty('voice', voice_id)

Если кластеризуешь по одному-двум столбцам, то тривиально.
Если же более чем по двум, используй приёмы уменьшения размерности, например, метод главных компонент, чтобы найти такие сочетания столбцов, которые хорошо описывают разделение данных на кластеры.

list(zip(sess, tasks)) должно сгенерить список пар "сессия, задача". Дальше уже с каждой парой работаешь.