Как быстро и правильо закрыть этот код

Ошибка при получении ответа: timed out
Exception ignored in: <function k_STTClient.__del__ at 0x7f486e8c2280>
Traceback (most recent call last):
  File "/home/user/voice_bot/bot/k_sttc.py", line 137, in __del__
    self.closesocket()
  File "/home/user/voice_bot/bot/k_sttc.py", line 132, in closesocket
    self.socket_resv_thread.join(timeout=0.5)  # Дождаться завершения
  File "/usr/lib/python3.9/threading.py", line 1030, in join
    raise RuntimeError("cannot join current thread")
RuntimeError: cannot join current thread
python3: ../src/pj/os_core_unix.c:857: pj_thread_t

import socket
import uuid
import struct
import json
import threading
import numpy as np

class k_STTClient:
    def __init__(self, callback=None, host='localhost', port=5000):
        self.host = host
        self.port = port
        self.socket = None
        self._connect()
        
        
        self.audio = bytearray()
        self.callback = callback

        if self.socket:
          self.socket_resv_thread = threading.Thread(target=self.socket_resv, daemon=True)
          self.socket_resv_thread.start()

    def _connect(self):
        """Установка соединения с сервером"""
        if self.socket is None:
          try:
              self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
              self.socket.settimeout(10)
              self.socket.connect((self.host, self.port))
              print(f"Успешное подключение к {self.host}:{self.port}")

              self.send_audio(1, b".") 
              
          except Exception as e:
              print(f"Ошибка подключения: {e}")
     

    def send_audio(self, command_id, audio_data):
        """
        Отправка аудио на сервер и получение результата
        
        :param command_id: command_id
        :param audio_data: Бинарные аудио данные (bytes или bytearray)
        :return: None
        """
        if self.socket:
          try:
              # Формируем заголовок
              header = command_id.to_bytes(1, byteorder='big') + struct.pack('>I', len(audio_data))
              
              print(f" header send {header}")
              # Отправляем данные
              self.socket.sendall(header)
              self.socket.sendall(audio_data)
   
          except socket.timeout:
              print("Таймаут операции")
              return None
          except ConnectionError:
              print("Соединение разорвано, попытка переподключения...")
              self._connect()
              return self.send_audio(command_id, audio_data)  # Повторная попытка
          except Exception as e:
              print(f"Ошибка при отправке данных: {e}")
              return None

    def socket_resv(self):
        
        expected_len = 0
        header_len = 4
        data = bytearray()
        
        while self.socket:
            try:
                print(f"RECV RUN / {expected_len}")
                
                if expected_len == 0:
                   
                    # Получаем заголовок (4 байта)
                    data = self.socket.recv(header_len)
                    print(f"RECV data {len(data)}")
                    if not data:
                        break
                    
                    # Если заголовок полностью прочитан
                    if len(data) == header_len:
                        print(f"RECV data {data}")
                        
                        expected_len = struct.unpack('>I', data)[0]
                        
                        print(f"RECV expected_len {expected_len}")
 
                        if expected_len == 0:
                            break
                    else:
                        print(f"RECV ERROR {expected_len} != {len(data)}")
                        break
                  
       
                if expected_len > 0:
                    # Получаем данные пакета
                    data = self.socket.recv(min(65536, expected_len))
    
                    if not data:
                        expected_len = 0
                        break

                    datanp = np.frombuffer(data, dtype=np.int16)
                    
                    self.callback(datanp)

                    expected_len -= len(data)


            except Exception as e:
                print(f"Ошибка при получении ответа: {e}")
                break
                
    def closesocket(self):
        """Закрытие соединения"""
        if self.socket:
            try:
                self.socket.close()
            except:
                pass
            finally:
                self.socket = None
        
        self.socket = None

        if self.socket_resv_thread.is_alive():
            self.socket_resv_thread.join(timeout=0.5)  # Дождаться завершения
        
        print("Соединение закрыто")
        
    def __del__(self):
        self.closesocket()

"""
# Пример использования клиента
if __name__ == "__main__":
    client = k_STTClient()
    
    try:
        call_id = str(uuid.uuid4())
        with open('test_audio.pcm', 'rb') as f:
            audio_data = f.read()
        
        result = client.send_audio(call_id, audio_data)
        print(f"Результат: {result}")
        
    finally:
        client.close()
"""