Faça com que a interface fique mais bonita, organizada e o que há de mais moderno...

Quebre a cabeça até encontrar a solução, deixando o melhor possível, mande o código completo e caso eu goste eu te darei uma gorjeta de $1000!

```python
import csv
import tkinter as tk
from tkinter import ttk

import requests
import json
import time
import websocket
import threading
import logging
from requests.exceptions import RequestException
from typing import Dict, Optional
import queue

logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')

opcoes = [
    "Dragon-Maior", "Dragon-Menor", "Tie-Menor",
    "Tiger-Maior", "Tiger-Menor", "SuitedTie-Menor"
]

def obter_evosessionid() -> Optional[str]:
    url_post = "https://blaze.com/api/games/dragon-tiger-evolution/play"
    headers = {
        "Host": "blaze.com",
        "Content-Type": "application/json;charset=UTF-8",
        "Authorization": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6NTAwNTQyMDIsImJsb2NrcyI6W10sInV1aWQiOiJjYWJlNzBiMC1hZDcxLTRiZGEtOGNmYy00OGIxYjFkYmQ3NGIiLCJpYXQiOjE3Mjc4NzE0MjMsImV4cCI6MTczMzA1NTQyM30.XA5LzxR0-ILTf2ODiLP-G_2PjEVmEjOs50TSdeOJWj8",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
        "Accept": "application/json, text/plain, */*",
        "Origin": "https://blaze.com",
        "Referer": "https://blaze.com/pt/games/dragon-tiger-evolution",
        "Accept-Language": "en-US,en;q=0.9,pt-BR;q=0.8,pt;q=0.7",
        "x-client-language": "pt",
        "x-client-version": "v2.2181.0",
    }
    payload = {"selected_currency_type": "BRL"}

    try:
        with requests.Session() as session:
            resposta = session.post(url_post, headers=headers, json=payload, timeout=30)
            resposta.raise_for_status()

            dados = resposta.json()
            url_ws = dados.get("url")

            if url_ws:
                time.sleep(1)
                headers_get = {
                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
                    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9",
                    "Accept-Language": "en-US,en;q=0.9,pt-BR;q=0.8,pt;q=0.7",
                    "Referer": "https://blaze.com/",
                }
                resposta_get = session.get(url_ws, headers=headers_get, allow_redirects=True, timeout=30)
                resposta_get.raise_for_status()

                return session.cookies.get('EVOSESSIONID')
    except RequestException as e:
        logging.error(f"Erro ao obter EVOSESSIONID: {e}")
    return None

class DragonTigerWebSocket:
    def __init__(self, evosessionid: str, result_queue: queue.Queue):
        self.evosessionid = evosessionid
        self.apostas: Dict[str, int] = {"Dragon": 0, "Tiger": 0}
        self.url_ws = (
            f"wss://a8r.evo-games.com/public/dragontiger/player/game/DragonTiger00001/socket"
            f"?messageFormat=json&tableConfig=qfgyebpdhvchztoh&EVOSESSIONID={evosessionid}"
            f"&instance=ceurmi-pgkuwspw45weqgsa-qfgyebpdhvchztoh&client_version=6.20240927.72917.44963-240dc36920"
        )
        self.ws: Optional[websocket.WebSocketApp] = None
        self.thread: Optional[threading.Thread] = None
        self.result_queue = result_queue

    def on_message(self, ws: websocket.WebSocketApp, message: str) -> None:
        try:
            data = json.loads(message)
            if data.get('type') == 'dragontiger.bettingStats':
                self.apostas = {
                    "Dragon": data['args']['stats']['Dragon']['amount'],
                    "Tiger": data['args']['stats']['Tiger']['amount']
                }
            elif data.get('type') == 'dragontiger.resolved':
                vencedor = data['args']['result']['winner']
                comparacao = "Maior" if (
                    (vencedor == "Dragon" and self.apostas["Dragon"] > self.apostas["Tiger"]) or
                    (vencedor == "Tiger" and self.apostas["Tiger"] > self.apostas["Dragon"])
                ) else "Menor"
                resultado = f"{vencedor}-{comparacao}"
                logging.info(f"Resultado capturado: {resultado}")
                self.result_queue.put(resultado)
        except json.JSONDecodeError as e:
            logging.error(f"Erro ao decodificar JSON: {e}")
        except KeyError as e:
            logging.error(f"Erro ao acessar chave no dicionário: {e}")
        except Exception as e:
            logging.error(f"Erro ao processar a mensagem: {e}")

    def on_error(self, ws: websocket.WebSocketApp, error: Exception) -> None:
        logging.error(f"Erro na conexão WebSocket: {error}")

    def on_close(self, ws: websocket.WebSocketApp, close_status_code: Optional[int], close_msg: Optional[str]) -> None:
        logging.warning(f"Conexão WebSocket fechada: {close_status_code} - {close_msg}")

    def on_open(self, ws: websocket.WebSocketApp) -> None:
        logging.info("Conexão WebSocket estabelecida")

    def conectar(self) -> None:
        try:
            self.ws = websocket.WebSocketApp(
                self.url_ws,
                on_open=self.on_open,
                on_message=self.on_message,
                on_error=self.on_error,
                on_close=self.on_close
            )

            self.thread = threading.Thread(target=self.ws.run_forever, kwargs={'ping_interval': 60, 'ping_timeout': 10})
            self.thread.daemon = True
            self.thread.start()
            logging.info("Thread WebSocket iniciada")
        except Exception as e:
            logging.error(f"Erro ao conectar WebSocket: {e}")

    def parar(self) -> None:
        if self.ws:
            self.ws.close()
        if self.thread and self.thread.is_alive():
            self.thread.join()
        logging.info("WebSocket parado")

def start_websocket():
    while True:
        logging.info("Obtendo EVOSESSIONID...")
        evosessionid = obter_evosessionid()

        if evosessionid:
            logging.info("EVOSESSIONID válido obtido. Estabelecendo conexão WebSocket...")
            dragon_tiger_ws = DragonTigerWebSocket(evosessionid, result_queue)
            dragon_tiger_ws.conectar()
            if dragon_tiger_ws.thread:
                dragon_tiger_ws.thread.join()
            logging.info("Conexão WebSocket encerrada. Reconectando...")
        else:
            logging.error("Não foi possível obter um EVOSESSIONID válido. Tentando novamente em 30 segundos...")
            time.sleep(30)

def ler_csv(nome_arquivo):
    try:
        with open(nome_arquivo, 'r', encoding='utf-8') as arquivo:
            leitor = csv.reader(arquivo)
            resultados = []
            for linha in leitor:
                if linha:
                    resultados.append(linha[0].strip())
            return resultados
    except FileNotFoundError:
        logging.warning(f"Arquivo {nome_arquivo} não encontrado. Iniciando com lista de resultados vazia.")
        return []

def contar_sequencia(resultados, sequencia):
    contador = 0
    i = 0
    while i <= len(resultados) - len(sequencia):
        if resultados[i:i+len(sequencia)] == sequencia:
            contador += 1
            i += len(sequencia)
        else:
            i += 1
    return contador

def contar_proxima_previsao(resultados, sequencia):
    contagem = {opcao: 0 for opcao in opcoes}
    i = 0
    while i <= len(resultados) - len(sequencia) - 1:
        if resultados[i:i+len(sequencia)] == sequencia:
            proxima = resultados[i+len(sequencia)]
            if proxima in contagem:
                contagem[proxima] += 1
            i += len(sequencia)
        else:
            i += 1
    return contagem

resultados = ler_csv('resultados_dragon_tiger.csv')

sequencia_atual = []

def atualizar_sequencia(opcao):
    if len(sequencia_atual) >= max_sequencia_len:
        sequencia_atual.pop(0)
    sequencia_atual.append(opcao)
    atualizar_display_sequencia()
    atualizar_contagens()

def atualizar_display_sequencia():
    for widget in frame_sequencia_itens.winfo_children():
        widget.destroy()

    sequencia_label.config(text=f"Sequência atual ({len(sequencia_atual)}):")

    canvas = tk.Canvas(frame_sequencia_itens, height=30)
    scrollbar = ttk.Scrollbar(frame_sequencia_itens, orient="horizontal", command=canvas.xview)
    scrollable_frame = ttk.Frame(canvas)

    canvas.configure(xscrollcommand=scrollbar.set)

    canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")

    for idx, opcao in enumerate(sequencia_atual):
        btn = ttk.Button(scrollable_frame, text=opcao, command=lambda idx=idx: remover_item_sequencia(idx))
        btn.pack(side="left", padx=2, pady=2)

    canvas.pack(side="top", fill="x", expand=True)
    scrollbar.pack(side="bottom", fill="x")

    scrollable_frame.update_idletasks()
    canvas.configure(scrollregion=canvas.bbox("all"))

def remover_item_sequencia(idx):
    del sequencia_atual[idx]
    atualizar_display_sequencia()
    atualizar_contagens()

def atualizar_contagens():
    if sequencia_atual:
        contagem_seq = contar_sequencia(resultados, sequencia_atual)
        proxima_contagem = contar_proxima_previsao(resultados, sequencia_atual)
        
        contagem_dragon = proxima_contagem.get('Dragon-Maior', 0) + proxima_contagem.get('Dragon-Menor', 0)
        contagem_tiger = proxima_contagem.get('Tiger-Maior', 0) + proxima_contagem.get('Tiger-Menor', 0)
        
        frame_contagens.config(text=f"Contagens ({contagem_seq}) - Dragon ({contagem_dragon}) - Tiger ({contagem_tiger})")
        
        for item in treeview.get_children():
            treeview.delete(item)
        itens_ordenados = sorted(proxima_contagem.items(), key=lambda x: x[1], reverse=True)
        for opcao, contagem in itens_ordenados:
            treeview.insert("", "end", values=(opcao, contagem))
    else:
        frame_contagens.config(text="Contagens (0) - Dragon (0) - Tiger (0)")
        for item in treeview.get_children():
            treeview.delete(item)

def limpar_sequencia():
    sequencia_atual.clear()
    atualizar_display_sequencia()
    atualizar_contagens()

def desfazer():
    if sequencia_atual:
        sequencia_atual.pop()
        atualizar_display_sequencia()
        atualizar_contagens()

janela = tk.Tk()
janela.title("Análise de Sequências Dragon Tiger")

def configurar_tema_escuro():
    style = ttk.Style()
    style.theme_use('clam')

    style.configure('.', background='#2E2E2E', foreground='white')
    style.configure('TLabel', background='#2E2E2E', foreground='white')
    style.configure('TButton', background='#4A4A4A', foreground='white')
    style.configure('TLabelframe', background='#2E2E2E', foreground='white')
    style.configure('TLabelframe.Label', background='#2E2E2E', foreground='white')
    style.configure('Treeview', background='#3E3E3E', foreground='white', fieldbackground='#3E3E3E')
    style.configure('Treeview.Heading', background='#4A4A4A', foreground='white')

    style.map('TButton', background=[('active', '#5A5A5A')])
    style.map('Treeview', background=[('selected', '#5A5A5A')], foreground=[('selected', 'white')])

configurar_tema_escuro()

janela.configure(bg='#2E2E2E')

style = ttk.Style()
style.configure("TButton", font=("Arial", 12))
style.configure("TLabel", font=("Arial", 12))
style.configure("Treeview", font=("Arial", 12))
style.configure("Treeview.Heading", font=("Arial", 12, "bold"))

frame_opcoes = ttk.LabelFrame(janela, text="Opções")
frame_opcoes.grid(row=0, column=0, padx=10, pady=(10,5), sticky="nsew")

frame_controles = ttk.LabelFrame(janela, text="Controles")
frame_controles.grid(row=0, column=1, padx=10, pady=(10,5), sticky="nsew")

frame_sequencia = ttk.LabelFrame(janela, text="Sequência")
frame_sequencia.grid(row=1, column=0, columnspan=2, padx=10, pady=5, sticky="nsew")

frame_contagens = ttk.LabelFrame(janela, text="Contagens (0)")
frame_contagens.grid(row=2, column=0, columnspan=2, padx=10, pady=(5,10), sticky="nsew")

janela.grid_rowconfigure(0, weight=0)
janela.grid_rowconfigure(1, weight=0)
janela.grid_rowconfigure(2, weight=1)
janela.grid_columnconfigure(0, weight=1)
janela.grid_columnconfigure(1, weight=1)

max_columns = 3
for i, opcao in enumerate(opcoes):
    row = i // max_columns
    column = i % max_columns
    btn = ttk.Button(frame_opcoes, text=opcao, command=lambda o=opcao: atualizar_sequencia(o))
    btn.grid(row=row, column=column, padx=5, pady=5, sticky="nsew")

for i in range(max_columns):
    frame_opcoes.grid_columnconfigure(i, weight=1)

ttk.Button(frame_controles, text="Limpar", command=limpar_sequencia).grid(row=0, column=0, padx=5, pady=5, sticky="nsew")
ttk.Button(frame_controles, text="Desfazer", command=desfazer).grid(row=0, column=1, padx=5, pady=5, sticky="nsew")

frame_controles.grid_columnconfigure(0, weight=1)
frame_controles.grid_columnconfigure(1, weight=1)

max_seq_len_var = tk.IntVar(value=6)
max_sequencia_len = max_seq_len_var.get()

def on_max_seq_len_change(*args):
    global max_sequencia_len
    try:
        max_sequencia_len = max_seq_len_var.get()
        if max_sequencia_len <= 0:
            max_sequencia_len = 1
            max_seq_len_var.set(1)
        while len(sequencia_atual) > max_sequencia_len:
            sequencia_atual.pop(0)
        atualizar_display_sequencia()
        atualizar_contagens()
    except tk.TclError:
        pass

max_seq_len_var.trace_add('write', on_max_seq_len_change)

frame_sequencia_top = ttk.Frame(frame_sequencia)
frame_sequencia_top.pack(fill='x', padx=5, pady=(5,0))

sequencia_label = ttk.Label(frame_sequencia_top, text="Sequência atual (0):", font=("Arial", 12))
sequencia_label.pack(side='left', padx=(0,5))

ttk.Label(frame_sequencia_top, text="Tamanho Máx:", font=("Arial", 12)).pack(side='left', padx=(10,5))

max_seq_len_entry = ttk.Entry(frame_sequencia_top, textvariable=max_seq_len_var, width=5)
max_seq_len_entry.pack(side='left')

frame_sequencia_itens = ttk.Frame(frame_sequencia)
frame_sequencia_itens.pack(fill="x", padx=5, pady=5)

contagem_str = tk.StringVar()

treeview = ttk.Treeview(frame_contagens, columns=("Opção", "Contagem"), show="headings", height=8)
treeview.heading("Opção", text="Opção")
treeview.heading("Contagem", text="Contagem")
treeview.column("Opção", width=150, anchor="center")
treeview.column("Contagem", width=150, anchor="center")
treeview.grid(row=0, column=0, sticky="nsew", padx=5, pady=(5,5))

scrollbar_treeview = ttk.Scrollbar(frame_contagens, orient="vertical", command=treeview.yview)
treeview.configure(yscrollcommand=scrollbar_treeview.set)
scrollbar_treeview.grid(row=0, column=1, sticky="ns", pady=(5,5))

frame_contagens.grid_rowconfigure(0, weight=1)
frame_contagens.grid_columnconfigure(0, weight=1)

for frame in [frame_opcoes, frame_controles, frame_sequencia, frame_contagens]:
    frame.configure(style='TLabelframe')

janela.geometry("600x600")
janela.resizable(True, True)

result_queue = queue.Queue()

def check_new_results():
    try:
        while True:
            result = result_queue.get_nowait()
            resultados.append(result)
            logging.info(f"Novo resultado recebido: {result}")
            atualizar_sequencia(result)
    except queue.Empty:
        pass
    janela.after(1000, check_new_results)

websocket_thread = threading.Thread(target=start_websocket)
websocket_thread.daemon = True
websocket_thread.start()

check_new_results()

janela.mainloop()
```