416 lines
16 KiB
Python
416 lines
16 KiB
Python
import tkinter as tk
|
|
from tkinter import filedialog, messagebox, ttk
|
|
import threading
|
|
import socket
|
|
import time
|
|
import binascii
|
|
import requests
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
|
|
def hexspace(data, n):
|
|
return " ".join([data[i:i + n] for i in range(0, len(data), n)])
|
|
|
|
session = requests.Session()
|
|
session.headers.update({"Connection": "keep-alive"})
|
|
|
|
class DataReceiver:
|
|
def __init__(self):
|
|
self.running = False
|
|
self.file_mode = False
|
|
self.file_path = None
|
|
self.manual_mode = False
|
|
|
|
def start_tcp(self, host, port, callback):
|
|
self.running = True
|
|
def run():
|
|
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
|
|
s.bind((host, port))
|
|
s.listen(1)
|
|
conn, addr = s.accept()
|
|
with conn:
|
|
while self.running:
|
|
data = conn.recv(1024)
|
|
if data:
|
|
callback(data.decode('utf-8'))
|
|
threading.Thread(target=run, daemon=True).start()
|
|
|
|
def start_file(self, callback, timeout):
|
|
self.running = True
|
|
def run():
|
|
if not self.file_path:
|
|
return
|
|
with open(self.file_path, 'r') as f:
|
|
while self.running:
|
|
if self.manual_mode:
|
|
continue
|
|
line = f.readline()
|
|
if line:
|
|
callback(eval(line.strip().split(" DEBUG ")[1]))
|
|
time.sleep(timeout)
|
|
threading.Thread(target=run, daemon=True).start()
|
|
|
|
def read_next_line(self, callback):
|
|
if not self.file_path:
|
|
return
|
|
with open(self.file_path, 'r') as f:
|
|
line = f.readline()
|
|
if line:
|
|
callback(eval(line.strip().split(" DEBUG ")[1]))
|
|
|
|
def stop(self):
|
|
self.running = False
|
|
|
|
class DataSender:
|
|
def __init__(self):
|
|
self.targets = []
|
|
self.session = requests.Session()
|
|
self.session.headers.update({"Connection": "keep-alive"})
|
|
|
|
def add_target(self, host, port):
|
|
self.targets.append((host, port))
|
|
|
|
|
|
def send(self, data):
|
|
"""Многопоточная отправка данных на все указанные цели."""
|
|
if not self.targets:
|
|
print("No targets available to send data.")
|
|
return
|
|
|
|
def send_to_target(target):
|
|
host, port = target
|
|
url = f"http://{host}:{port}/API/"
|
|
try:
|
|
for k, v in data.items():
|
|
par = "SetText" if k.split(".")[1] == "Text" else "SetImage"
|
|
params = {
|
|
"Function": par,
|
|
"Input": 51,
|
|
"SelectedName": k,
|
|
"Value": v,
|
|
}
|
|
response = self.session.get(url, params=params, timeout=5)
|
|
response.raise_for_status() # Проверяет, есть ли ошибки HTTP
|
|
except requests.exceptions.RequestException as e:
|
|
print(f"Error sending data to {host}:{port}: {e}")
|
|
|
|
# Используем ThreadPoolExecutor для многопоточной отправки
|
|
with ThreadPoolExecutor(max_workers=5) as executor: # max_workers можно настроить
|
|
executor.map(send_to_target, self.targets)
|
|
|
|
|
|
# def send(self, data):
|
|
# for host, port in self.targets:
|
|
# try:
|
|
# url = f"http://{host}:{port}/API/"
|
|
# print(data)
|
|
# for k,v in data.items():
|
|
# par = "SetText" if k.split(".")[1] == "Text" else "SetImage"
|
|
# params = {
|
|
# "Function": par,
|
|
# "Input": 51,
|
|
# "SelectedName": k,
|
|
# "Value": v,
|
|
# }
|
|
# session.get(url, params=params)
|
|
# except Exception as e:
|
|
# print(f"Error sending data to {host}:{port}: {e}")
|
|
|
|
# def send(self, data):
|
|
# for host, port in self.targets:
|
|
# try:
|
|
# with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
|
|
# s.connect((host, port))
|
|
# s.sendall(data.encode('utf-8'))
|
|
# except Exception as e:
|
|
# print(f"Error sending data to {host}:{port}: {e}")
|
|
|
|
class DataProcessor:
|
|
def process_protocol_a(self, data):
|
|
return data.upper()
|
|
|
|
def process_protocol_b(self, data):
|
|
return data[::-1]
|
|
|
|
def process_protocol_saratov(self, data):
|
|
if data == "\xff":
|
|
return
|
|
|
|
cdata = binascii.hexlify(data)
|
|
ddata = cdata.decode("utf-8").upper()
|
|
edata = hexspace(ddata, 2)
|
|
temp = edata.split("FF 52")
|
|
# results = []
|
|
for i in temp:
|
|
try:
|
|
minutes = int(i.split()[5], 16)
|
|
seconds = int(i.split()[6], 16)
|
|
timer_str = f"{minutes}:{seconds:02d}" if seconds < 60 else f"{minutes}.{seconds-128}"
|
|
|
|
seconds_24 = int(i.split()[7], 16)
|
|
timer_attack = ""
|
|
timer_pic = "D:\Графика\БАСКЕТБОЛ\ЕДИНАЯ ЛИГА ВТБ 2022-2023\Scorebug Indicators\\24Sec_Orange.png"
|
|
if seconds_24 != 255:
|
|
if seconds_24 > 127:
|
|
seconds_24 -= 128
|
|
timer_attack = f"{seconds_24//10}.{seconds_24%10}"
|
|
timer_pic = "D:\Графика\БАСКЕТБОЛ\ЕДИНАЯ ЛИГА ВТБ 2022-2023\Scorebug Indicators\\24Sec_Red.png"
|
|
else:
|
|
timer_attack = seconds_24
|
|
|
|
quarter = int(i.split()[14][1], 16)
|
|
timeout1 = int(i.split()[10], 16)
|
|
timeout2 = int(i.split()[11], 16)
|
|
score1 = int(i.split()[8], 16)
|
|
score2 = int(i.split()[9], 16)
|
|
foul1 = int(i.split()[12], 16)
|
|
foul2 = int(i.split()[13], 16)
|
|
|
|
data = {
|
|
"TIMER.Text": timer_str,
|
|
"ATTACK.Text": timer_attack,
|
|
"Score_Home.Text": score1,
|
|
"Score_Away.Text": score2,
|
|
"fouls1.Source": f"D:\Графика\БАСКЕТБОЛ\ЕДИНАЯ ЛИГА ВТБ 2022-2023\Scorebug Indicators\Home_{foul1}.png",
|
|
"fouls2.Source": f"D:\Графика\БАСКЕТБОЛ\ЕДИНАЯ ЛИГА ВТБ 2022-2023\Scorebug Indicators\Away_{foul2}.png",
|
|
"24SECBACKGROUND.Source": timer_pic,
|
|
}
|
|
|
|
# results.append(data)
|
|
except (IndexError, ValueError):
|
|
continue
|
|
|
|
return data
|
|
|
|
class App:
|
|
def __init__(self, root):
|
|
self.receiver = DataReceiver()
|
|
self.sender = DataSender()
|
|
self.processor = DataProcessor()
|
|
|
|
self.protocol_var = tk.StringVar(value="Protocol A")
|
|
self.mode_var = tk.StringVar(value="Log File")
|
|
self.read_mode_var = tk.StringVar(value="Automatic")
|
|
self.timeout_var = tk.DoubleVar(value=0.5)
|
|
|
|
self.create_ui(root)
|
|
|
|
def display_data(self, data):
|
|
protocol = self.protocol_var.get()
|
|
if protocol == "Protocol A":
|
|
processed_data = self.processor.process_protocol_a(data)
|
|
elif protocol == "Protocol B":
|
|
processed_data = self.processor.process_protocol_b(data)
|
|
elif protocol == "Saratov":
|
|
processed_data = self.processor.process_protocol_saratov(data)
|
|
else:
|
|
processed_data = data
|
|
|
|
if processed_data:
|
|
self.update_send_status(True)
|
|
self.sender.send(processed_data)
|
|
self.update_send_status(False)
|
|
|
|
self.log_text.insert(tk.END, f"{data}\n")
|
|
self.log_text.see(tk.END)
|
|
|
|
self.processed_data_text.insert(tk.END, f"{processed_data}\n")
|
|
self.processed_data_text.see(tk.END)
|
|
|
|
def create_ui(self, root):
|
|
root.title("Data Processing Application")
|
|
|
|
self.notebook = ttk.Notebook(root)
|
|
self.notebook.pack(fill="both", expand=True)
|
|
|
|
self.settings_frame = tk.Frame(self.notebook)
|
|
self.game_frame = tk.Frame(self.notebook)
|
|
|
|
self.notebook.add(self.settings_frame, text="Settings")
|
|
self.notebook.add(self.game_frame, text="Game")
|
|
|
|
self.create_settings_ui(self.settings_frame)
|
|
self.create_game_ui(self.game_frame)
|
|
|
|
def create_settings_ui(self, frame):
|
|
frame_receive = tk.LabelFrame(frame, text="Receive Data")
|
|
frame_receive.pack(fill="x", padx=5, pady=5)
|
|
|
|
tk.Label(frame_receive, text="Select Mode:").pack(side="left", padx=5, pady=5)
|
|
tk.OptionMenu(frame_receive, self.mode_var, "Log File", "TCP Connection", command=self.update_mode).pack(side="left", padx=5, pady=5)
|
|
|
|
self.file_button = tk.Button(frame_receive, text="Select Log File", command=self.select_file)
|
|
|
|
self.tcp_frame = tk.Frame(frame_receive)
|
|
tk.Label(self.tcp_frame, text="IP:").pack(side="left")
|
|
self.tcp_ip_entry = tk.Entry(self.tcp_frame)
|
|
self.tcp_ip_entry.pack(side="left", padx=5)
|
|
self.tcp_ip_entry.insert(0, "192.168.127.254") # например, default IP адрес
|
|
tk.Label(self.tcp_frame, text="Port:").pack(side="left")
|
|
self.tcp_port_entry = tk.Entry(self.tcp_frame)
|
|
self.tcp_port_entry.pack(side="left", padx=5)
|
|
self.tcp_port_entry.insert(0, 1993) # например, default порт
|
|
|
|
self.read_mode_frame = tk.Frame(frame_receive)
|
|
tk.Label(self.read_mode_frame, text="Read Mode:").pack(side="left", padx=5, pady=5)
|
|
tk.OptionMenu(self.read_mode_frame, self.read_mode_var, "Automatic", "Manual", command=self.update_read_mode).pack(side="left", padx=5, pady=5)
|
|
tk.Label(self.read_mode_frame, text="Timeout (s):").pack(side="left", padx=5, pady=5)
|
|
self.timeout_entry = tk.Entry(self.read_mode_frame, textvariable=self.timeout_var)
|
|
self.timeout_entry.pack(side="left", padx=5)
|
|
self.manual_read_button = tk.Button(self.read_mode_frame, text="Read Next Line", command=self.read_next_line)
|
|
|
|
self.start_button = tk.Button(frame_receive, text="Start", command=self.start_receiving)
|
|
self.start_button.pack(side="left", padx=5, pady=5)
|
|
tk.Button(frame_receive, text="Stop", command=self.stop_receiving).pack(side="left", padx=5, pady=5)
|
|
|
|
frame_process = tk.LabelFrame(frame, text="Process Data")
|
|
frame_process.pack(fill="x", padx=5, pady=5)
|
|
|
|
tk.Label(frame_process, text="Select Protocol:").pack(side="left", padx=5, pady=5)
|
|
tk.OptionMenu(frame_process, self.protocol_var, "Protocol A", "Protocol B", "Saratov").pack(side="left", padx=5, pady=5)
|
|
|
|
frame_send = tk.LabelFrame(frame, text="Send Data")
|
|
frame_send.pack(fill="x", padx=5, pady=5)
|
|
|
|
self.target_count_var = tk.IntVar(value=1)
|
|
tk.Label(frame_send, text="Number of Targets:").pack(side="left", padx=5, pady=5)
|
|
tk.Spinbox(frame_send, from_=1, to=10, textvariable=self.target_count_var, command=self.update_targets).pack(side="left", padx=5, pady=5)
|
|
|
|
self.targets_frame = tk.Frame(frame_send)
|
|
self.targets_frame.pack(fill="x", padx=5, pady=5)
|
|
self.target_entries = []
|
|
self.update_targets()
|
|
|
|
tk.Button(frame_send, text="Send Data", command=self.send_data).pack(side="left", padx=5, pady=5)
|
|
|
|
self.update_mode(self.mode_var.get())
|
|
|
|
def create_game_ui(self, frame):
|
|
frame_status = tk.LabelFrame(frame, text="Status")
|
|
frame_status.pack(fill="x", padx=5, pady=5)
|
|
|
|
self.data_receive_status = tk.Label(frame_status, text="Receiving Data: Not Active", fg="red")
|
|
self.data_receive_status.pack(pady=5)
|
|
|
|
self.data_send_status = tk.Label(frame_status, text="Sending Data: Not Active", fg="red")
|
|
self.data_send_status.pack(pady=5)
|
|
|
|
frame_log = tk.LabelFrame(frame, text="Log")
|
|
frame_log.pack(fill="both", expand=True, padx=5, pady=5)
|
|
|
|
self.log_text = tk.Text(frame_log, height=10, state="normal")
|
|
self.log_text.pack(fill="both", expand=True, padx=5, pady=5)
|
|
|
|
frame_processed = tk.LabelFrame(frame, text="Processed Data")
|
|
frame_processed.pack(fill="both", expand=True, padx=5, pady=5)
|
|
|
|
self.processed_data_text = tk.Text(frame_processed, height=10, state="normal")
|
|
self.processed_data_text.pack(fill="both", expand=True, padx=5, pady=5)
|
|
|
|
def update_mode(self, mode):
|
|
if mode == "Log File":
|
|
self.file_button.pack(side="left", padx=5, pady=5)
|
|
self.tcp_frame.pack_forget()
|
|
self.read_mode_frame.pack(fill="x", padx=5, pady=5)
|
|
self.start_button.config(state="normal")
|
|
else:
|
|
self.file_button.pack_forget()
|
|
self.read_mode_frame.pack_forget()
|
|
self.tcp_frame.pack(side="left", padx=5, pady=5)
|
|
self.start_button.config(state="normal")
|
|
|
|
def update_read_mode(self, mode):
|
|
if mode == "Automatic":
|
|
self.timeout_entry.config(state="normal")
|
|
self.manual_read_button.pack_forget()
|
|
self.receiver.manual_mode = False
|
|
else:
|
|
self.timeout_entry.config(state="disabled")
|
|
self.manual_read_button.pack(side="left", padx=5, pady=5)
|
|
self.receiver.manual_mode = True
|
|
|
|
def select_file(self):
|
|
self.receiver.file_path = filedialog.askopenfilename()
|
|
|
|
def start_receiving(self):
|
|
self.start_button.config(state="disabled")
|
|
mode = self.mode_var.get()
|
|
if mode == "Log File":
|
|
if self.receiver.file_path:
|
|
timeout = self.timeout_var.get() if self.read_mode_var.get() == "Automatic" else 0
|
|
self.receiver.start_file(self.display_data, timeout)
|
|
self.update_receive_status(True)
|
|
else:
|
|
messagebox.showerror("Error", "No file selected.")
|
|
elif mode == "TCP Connection":
|
|
host = self.tcp_ip_entry.get()
|
|
port = self.tcp_port_entry.get()
|
|
if host and port.isdigit():
|
|
self.receiver.start_tcp(host, int(port), self.display_data)
|
|
self.update_receive_status(True)
|
|
else:
|
|
messagebox.showerror("Error", "Invalid IP or port.")
|
|
self.start_button.config(state="normal")
|
|
|
|
def stop_receiving(self):
|
|
self.receiver.stop()
|
|
self.start_button.config(state="normal")
|
|
self.update_receive_status(False)
|
|
|
|
def read_next_line(self):
|
|
self.receiver.read_next_line(self.display_data)
|
|
|
|
def update_receive_status(self, active):
|
|
if active:
|
|
self.data_receive_status.config(text="Receiving Data: Active", fg="green")
|
|
else:
|
|
self.data_receive_status.config(text="Receiving Data: Not Active", fg="red")
|
|
|
|
def update_send_status(self, active):
|
|
if active:
|
|
self.data_send_status.config(text="Sending Data: Active", fg="green")
|
|
else:
|
|
self.data_send_status.config(text="Sending Data: Not Active", fg="red")
|
|
|
|
def update_targets(self):
|
|
for widget in self.targets_frame.winfo_children():
|
|
widget.destroy()
|
|
|
|
self.target_entries = []
|
|
for i in range(self.target_count_var.get()):
|
|
target_frame = tk.Frame(self.targets_frame)
|
|
target_frame.pack(fill="x", pady=2)
|
|
|
|
tk.Label(target_frame, text=f"Target {i+1} Host:").pack(side="left")
|
|
host_entry = tk.Entry(target_frame)
|
|
host_entry.pack(side="left", padx=5)
|
|
host_entry.insert(0, "127.0.0.1")
|
|
|
|
tk.Label(target_frame, text="Port:").pack(side="left")
|
|
port_entry = tk.Entry(target_frame)
|
|
port_entry.pack(side="left", padx=5)
|
|
port_entry.insert(0, 8088)
|
|
|
|
self.target_entries.append((host_entry, port_entry))
|
|
|
|
def send_data(self):
|
|
data = "Sample data to send"
|
|
if not data:
|
|
messagebox.showerror("No Data", "No data to send.")
|
|
return
|
|
|
|
self.sender.targets = []
|
|
for host_entry, port_entry in self.target_entries:
|
|
host = host_entry.get()
|
|
port = port_entry.get()
|
|
if host and port.isdigit():
|
|
self.sender.add_target(host, int(port))
|
|
|
|
self.update_send_status(True)
|
|
self.sender.send(data)
|
|
self.update_send_status(False)
|
|
|
|
if __name__ == "__main__":
|
|
root = tk.Tk()
|
|
app = App(root)
|
|
root.mainloop()
|