TypeError: bad operand type for unary -: 'tuple' как исправить ошибку

При отправке цифры float выводит ошибку TypeError: bad operand type for unary -: 'tuple'.

import sys, socket, json, struct
import pygame as pg


def rotate(surface, angle, pivot, offset):
    rotated_image = pg.transform.rotozoom(surface, -angle, 1)  # Rotate the image
    rotated_offset = offset.rotate(angle)  # Rotate the offset vector
    # Add the offset vector to the center/pivot point to shift the rect
    rect = rotated_image.get_rect(center=pivot+rotated_offset)
    return rotated_image, rect  # Return the rotated image and shifted rect

#def for move horizont
def update(surf, rect, y, ugol_tang, width):
    font = pg.font.Font(None, 48)
    rect.y += y

    ugol_tang_rend = font.render(str(ugol_tang), True, (0, 255, 0))
    surf.blit(ugol_tang_rend, (width / 2 + 180, rect.y-30))

#def for move arrow
def update_vert_skor(surf, rect, y, strelka_way, width):
    font = pg.font.Font(None, 48)
    rect.y += y

    ugol_tang_rend = font.render(str(strelka_way), True, (0, 255, 0))
    surf.blit(ugol_tang_rend, (width / 2 + 350, rect.y-15))


def main():
    clock = pg.time.Clock()
    W = 1920
    H = 1920
    screen = pg.display.set_mode((W, H))
    font = pg.font.Font(None, 64)

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect(('localhost', 9090))


    # Store the original center position of the surface
    pivot = [W/2+5, H/2+12]

    # This offset vector will be added to the pivot point, so the
    # resulting rect will be blitted at `rect.topleft + offset`
    offset = pg.math.Vector2(-5, -12)
    angle_kren = 0
    y_way = 0
    strelka_way = 0


    samolet_surf = pg.image.load('simv_samolet.png').convert_alpha()
    samolet_surf1 = pg.transform.scale(samolet_surf, (280, 120))
    # samolet_rect = samolet_surf1.get_rect(center=(W / 2, H / 2))

    pricel_surf = pg.image.load('nepod_pricel.png').convert_alpha()
    pricel_surf1 = pg.transform.scale(pricel_surf, (58, 58))
    pricel_rect = pricel_surf1.get_rect(center=(W/2+4, H/2+12))

    shkala_surf = pg.image.load('shkala.png').convert_alpha()
    shkala_surf1 = pg.transform.scale(shkala_surf, (360, 160))
    shkala_rect = shkala_surf1.get_rect(center=(W/2+4, H/2+88))

    gorizont_surf = pg.image.load('gorizont.png').convert_alpha()
    gorizont_surf1 = pg.transform.scale(gorizont_surf, (400, 5))
    gorizont_rect = gorizont_surf1.get_rect(center=(W/2+4, H/2-100))

    vert_skor_surf = pg.image.load('vert_skorost.png').convert_alpha()
    vert_skor_surf1 = pg.transform.scale(vert_skor_surf, (25, 400))
    vert_skor_rect = vert_skor_surf1.get_rect(center=(W / 2 + 250, H / 2 ))

    strelka_surf = pg.image.load('strelka.png').convert_alpha()
    strelka_surf1 = pg.transform.scale(strelka_surf, (100, 40))
    strelka_rect = strelka_surf1.get_rect(center=(W / 2 +310, H / 2))

    #text
    rast_do_toch = str('57,3')
    rast_do_toch_rend = font.render(rast_do_toch, True, (0,255,0))

    ugol_tang = 12
    vert_skor = 6

    while True:
        clock.tick(30)
        screen.fill((0,0,0))
        data = sock.recv(1024)
        angle_kren = struct.unpack('f', data)
        for event in pg.event.get():
            if event.type == pg.QUIT:
                pg.quit()
                sys.exit()
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_ESCAPE:
                    pg.quit()
                    sys.exit()
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_LEFT or event.key == pg.K_a:
                    angle_kren -= 1
                if event.key == pg.K_RIGHT or event.key == pg.K_d:
                    angle_kren += 1
                if event.key == pg.K_UP or event.key == pg.K_w:
                    y_way -= 1
                if event.key == pg.K_DOWN or event.key == pg.K_s:
                    y_way += 1
                if  event.key == pg.K_r:
                    strelka_way -= 1
                if  event.key == pg.K_f:
                    strelka_way += 1

        # Rotated version of the image and the shifted rect
        rotated_image, rect = rotate(samolet_surf1, angle_kren, pivot, offset)

        #horizont movement
        update(screen, gorizont_rect, y_way, ugol_tang, W)
        update_vert_skor(screen, strelka_rect, strelka_way, vert_skor, W)

        # Blit the rotated image
        screen.blit(rotated_image, rect)

        # screen.blit(samolet_surf1, samolet_rect)
        screen.blit(pricel_surf1, pricel_rect)
        screen.blit(shkala_surf1, shkala_rect)
        screen.blit(gorizont_surf1, gorizont_rect)
        screen.blit(vert_skor_surf1, vert_skor_rect)
        screen.blit(strelka_surf1, strelka_rect)
        # screen.blit(IMAGE, vert_skor_gorizont_rect)
        pg.draw.circle(screen, (30, 250, 70), pivot, 2)  # Pivot point
        # pg.draw.rect(screen, (30, 250, 70), rect, 1)  # The rect

        # show text
        screen.blit(rast_do_toch_rend, (W / 2, H - 300))

        #rotate all display
        config = json.load(open('config_ils.json'))
        rotate_screen = config['rotate_screen']
        screen.blit(pg.transform.rotate(screen, rotate_screen), (0, 0))
        pg.display.flip()

if __name__ == '__main__':
    pg.init()
    main()
    pg.quit()
    sys.exit()

angle_kren = struct.unpack('f', data) <--- эта часть кода, которая должна была конвертировать байт во флоат, однако код видит ее как tuplе. В интернете посмотрела как делать конверт байта во флоат и везде пишут этот способ. Но у меня она не работает. Какие еще есть способы? Как можно исправить?

Это код сервера:

import socket
import random
from time import sleep
import struct

#server

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    sock.bind(('', 9090))
    sock.listen(1)
    conn, addr = sock.accept()

    print ('connected:', addr)

    while True:
        x = round(random.uniform(0.5, 100), 2)
        print(type(x))
        y = struct.pack('f', x)
        print(y)
        conn.sendall(y)
        sleep(1)