Вот мой код python:
```py
import requests
import json
import time
import os


class DiscordFixManager:
    def __init__(self, base_url="http://127.0.0.1:7684"):
        self.base_url = base_url.rstrip('/')
        self.session = requests.Session()  # Use a session for persistent connections

    def _make_request(self, method, endpoint, payload=None):
        url = f"{self.base_url}/{endpoint}"
        try:
            response = self.session.request(method, url, json=payload, timeout=5)  # timeout added
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Ошибка запроса к {url}: {e}")
            return None

    def start_fix(self, mode):
        if mode not in ["general", "beeline", "mgts"]:
            print("Неверный режим. Доступные режимы: general, beeline, mgts")
            return None
        return self._make_request("POST", "start", {"mode": mode})

    def stop_fix(self):
        return self._make_request("POST", "terminate")

    def clear_driver(self):
        return self._make_request("POST", "clear-driver")

    def get_auto_start_settings(self):
        return self._make_request("GET", "auto-start-settings")

    def set_auto_start_settings(self, enabled, mode=None):
        if mode is not None and mode not in ["general", "beeline", "mgts", ""]:  # allow empty string for no mode
            print("Неверный режим. Доступные режимы: general, beeline, mgts, или пусто для без режима")
            return None

        return self._make_request("POST", "auto-start-settings", {"enabled": enabled, "mode": mode})

    def run_interactive_cli(self):
        while True:
            print("\nВыберите действие:")
            print("1. Запустить исправление")
            print("2. Остановить исправление")
            print("3. Очистить драйвер")
            print("4. Настроить автозапуск")
            print("5. Показать текущие настройки автозапуска")
            print("6. Выйти")

            choice = input("> ")

            try:
                choice = int(choice)  # Convert to integer for easier comparison

                if choice == 1:
                    mode = input("Введите режим (general, beeline, mgts): ")
                    result = self.start_fix(mode)
                    print(f"Результат: {result}")
                elif choice == 2:
                    result = self.stop_fix()
                    print(f"Результат: {result}")
                elif choice == 3:
                    result = self.clear_driver()
                    print(f"Результат: {result}")
                elif choice == 4:
                    while True:
                        auto_enabled = input("Включить автозапуск? (да/нет): ").lower()
                        if auto_enabled in ["да", "нет"]:
                            enabled = auto_enabled == "да"
                            break
                        else:
                            print("Неверный ввод. Введите 'да' или 'нет'.")

                    if enabled:
                        mode = input(
                            "Введите режим для автозапуска (general, beeline, mgts, или пусто для без режима): ")
                        if mode == "":
                            mode = None



                    else:
                        mode = None

                    result = self.set_auto_start_settings(enabled, mode)
                    print(f"Результат: {result}")

                elif choice == 5:
                    settings = self.get_auto_start_settings()
                    print(f"Текущие настройки автозапуска: {settings}")
                elif choice == 6:
                    break
                else:
                    print("Неверный выбор.")

            except ValueError:
                print("Неверный ввод. Пожалуйста, введите число.")

            time.sleep(1)


if __name__ == "__main__":
    manager = DiscordFixManager()
    manager.run_interactive_cli()
```

Вот код сервера rust:
```rs
use std::os::windows::process::CommandExt;
use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use std::process::{Child, Command, Stdio};
use std::sync::{Arc, Mutex};
use std::path::PathBuf;
use std::fs::{self, File};
use std::io::Write;
use actix_web::web::Data;
use winreg::{enums::*, RegKey};
use serde_json::json;


#[derive(Deserialize, Serialize, Clone, Debug)]
struct AutoStartSettings {
    enabled: bool,
    mode: Option<String>,
}

// Структура для глобального состояния
struct AppState {
    process: Mutex<Option<Child>>,
    auto_start_settings: Mutex<AutoStartSettings>,
}

// Структура для запроса на запуск
#[derive(Deserialize)]
struct StartRequest {
    mode: String, // "beeline", "mgts", "general"
}


async fn get_auto_start_settings(data: web::Data<Arc<AppState>>) -> impl Responder {
    let settings = data.auto_start_settings.lock().unwrap().clone();
    HttpResponse::Ok().json(settings)
}


async fn set_auto_start_settings(data: web::Data<Arc<AppState>>, req: web::Json<AutoStartSettings>) -> impl Responder {
    let mut settings_lock = data.auto_start_settings.lock().unwrap();
    *settings_lock = req.0.clone();

    // Сохранение настроек в файл
    let settings_file = File::create("auto_start_settings.json").expect("Unable to create file");
    serde_json::to_writer_pretty(settings_file, &*settings_lock).expect("Unable to write settings");


    // Обновление автозапуска
    if req.enabled {
        enable_autostart().unwrap_or_else(|e| println!("Enable autostart error: {}",e));
    } else {
        disable_autostart().unwrap_or_else(|e| println!("Disable autostart error: {}",e));
    }

    HttpResponse::Ok().json(req.0)
}



fn enable_autostart() -> Result<(), Box<dyn std::error::Error>> {
    let exe_path = std::env::current_exe()?;
    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
    let run = hkcu.open_subkey_with_flags(r#"Software\Microsoft\Windows\CurrentVersion\Run"#, KEY_WRITE)?;
    run.set_value("DiscordFix", &exe_path.to_str().unwrap_or(""))?;
    Ok(())
}

fn disable_autostart() -> Result<(), Box<dyn std::error::Error>> {
    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
    let run = hkcu.open_subkey_with_flags(r#"Software\Microsoft\Windows\CurrentVersion\Run"#, KEY_WRITE)?;
    run.delete_value("DiscordFix")?;
    Ok(())
}

// Функция для запуска процесса исправления Discord
async fn start_fix(data: Data<Arc<AppState>>, req: web::Json<StartRequest>) -> impl Responder {
    println!("Received start_fix request with mode: {}", req.mode);

    let mut process_lock = match data.process.lock() {
        Ok(lock) => lock,
        Err(e) => {
            eprintln!("Mutex lock error: {}", e);
            return HttpResponse::InternalServerError().body("Internal Server Error");
        }
    };

    if process_lock.is_some() {
        return HttpResponse::BadRequest().body("Процесс уже запущен");
    }

    let mode = req.mode.as_str();

    // Определение базового пути динамически
    let base_path = match std::env::current_exe() {
        Ok(exe_path) => exe_path.parent().map_or_else(|| PathBuf::from("."), |p| p.to_path_buf()),
        Err(e) => return HttpResponse::InternalServerError().body(format!("Ошибка получения пути к исполняемому файлу: {}", e)),
    };

    println!("Base path: {:?}", base_path);

    // Пути к необходимым файлам
    let bin_path = base_path.join("winws.exe");
    let quic_path = base_path.join("quic_initial_www_google_com.bin");
    let tls_path = base_path.join("tls_clienthello_www_google_com.bin");
    let list_path = base_path.join("list-discord.txt");

    // Проверка наличия необходимых файлов
    if !bin_path.exists() {
        return HttpResponse::InternalServerError().body("Не найден файл winws.exe");
    }
    if !quic_path.exists() {
        return HttpResponse::InternalServerError().body("Не найден файл quic_initial_www_google_com.bin");
    }
    if !tls_path.exists() {
        return HttpResponse::InternalServerError().body("Не найден файл tls_clienthello_www_google_com.bin");
    }
    if !list_path.exists() {
        return HttpResponse::InternalServerError().body("Не найден файл list-discord.txt");
    }

    // Создание команды
    let mut cmd = Command::new(&bin_path);

    // Добавление аргументов в зависимости от режима
    match mode {
        "general" => {
            cmd.args(&[
                "--wf-tcp=443",
                "--wf-udp=443,50000-65535",
                "--filter-udp=443",
                "--hostlist",
                list_path.to_str().expect("Invalid list path"),
                "--dpi-desync=fake",
                "--dpi-desync-udplen-increment=10",
                "--dpi-desync-repeats=6",
                "--dpi-desync-udplen-pattern=0xDEADBEEF",
                "--dpi-desync-fake-quic",
                quic_path.to_str().expect("Invalid quic path"),
                "--new",
                "--filter-udp=50000-65535",
                "--dpi-desync=fake",
                "--dpi-desync-any-protocol",
                "--dpi-desync-cutoff=d3",
                "--dpi-desync-repeats=6",
                "--dpi-desync-fake-quic",
                quic_path.to_str().expect("Invalid quic path"),
                "--new",
                "--filter-tcp=443",
                "--hostlist",
                list_path.to_str().expect("Invalid list path"),
                "--dpi-desync=fake,split",
                "--dpi-desync-autottl=2",
                "--dpi-desync-repeats=6",
                "--dpi-desync-fooling=badseq",
                "--dpi-desync-fake-tls",
                tls_path.to_str().expect("Invalid tls path"),
            ]);
        },
        "beeline" => {
            cmd.args(&[
                "--wf-udp=50000-65535",
                "--filter-udp=50000-65535",
                "--hostlist",
                list_path.to_str().expect("Invalid list path"),
                "--dpi-desync=fake",
                "--dpi-desync-any-protocol",
                "--dpi-desync-cutoff=d3",
                "--dpi-desync-repeats=6",
                "--dpi-desync-fake-quic",
                quic_path.to_str().expect("Invalid quic path"),
                "--new",
                "--wf-l3=ipv4",
                "--wf-tcp=443",
                "--dpi-desync=syndata",
                "--dpi-desync-split2",
                "--dpi-desync-disorder2",
                "--dpi-desync-fake-syndata",
                tls_path.to_str().expect("Invalid tls path"), // Используем tls_path как fake_syndata
                "--wssize",
                "1:6",
                "--dpi-desync-fake-syndata=",
                tls_path.to_str().expect("Invalid tls path"), // Используем tls_path как fake_syndata
            ]);
        },
        "mgts" => {
            cmd.args(&[
                "--wf-tcp=443",
                "--wf-udp=443,50000-65535",
                "--filter-udp=443",
                "--hostlist",
                list_path.to_str().expect("Invalid list path"),
                "--dpi-desync=fake",
                "--dpi-desync-udplen-increment=10",
                "--dpi-desync-repeats=6",
                "--dpi-desync-udplen-pattern=0xDEADBEEF",
                "--dpi-desync-fake-quic",
                quic_path.to_str().expect("Invalid quic path"),
                "--new",
                "--filter-udp=50000-65535",
                "--dpi-desync=fake,tamper",
                "--dpi-desync-any-protocol",
                "--dpi-desync-cutoff=d3",
                "--dpi-desync-repeats=6",
                "--dpi-desync-fake-quic",
                quic_path.to_str().expect("Invalid quic path"),
                "--new",
                "--filter-tcp=443",
                "--hostlist",
                list_path.to_str().expect("Invalid list path"),
                "--dpi-desync=fake",
                "--dpi-desync-autottl=2",
                "--dpi-desync-repeats=6",
                "--dpi-desync-fooling=md5sig",
                "--dpi-desync-fake-tls",
                tls_path.to_str().expect("Invalid tls path"),
            ]);
        },
        _ => panic!("Unknown mode: {}", mode), // Или верните ошибку HttpResponse::BadRequest(), как раньше
    }

    // Настройка запуска процесса
    let creation_result = cmd
        .current_dir(&base_path)
        .creation_flags(0x08000000) // CREATE_NO_WINDOW флаг для скрытия окна
        .stdout(Stdio::inherit()) // Или Stdio::null() для подавления вывода
        .stderr(Stdio::inherit()) // Или Stdio::null() для подавления вывода
        .spawn();


    match creation_result {
        Ok(child) => {
            println!("Process started successfully");
            *process_lock = Some(child);
            HttpResponse::Ok().body("Процесс запущен")
        },
        Err(e) => {
            eprintln!("Ошибка запуска процесса: {}", e);
            HttpResponse::InternalServerError().body(format!("Ошибка запуска процесса: {}", e))
        }
    }
}

// Функция для очистки драйвера WinDivert
async fn clear_driver(data: web::Data<Arc<AppState>>) -> impl Responder {
    println!("Received clear_driver request");

    // Команды для очистки драйвера
    let commands = vec![
        "sc stop WinDivert",
        "sc delete WinDivert",
    ];

    for cmd_str in commands {
        println!("Executing command: {}", cmd_str);

        let status = Command::new("cmd")
            .args(&["/C", cmd_str])
            .status();

        match status {
            Ok(status) if status.success() => {
                println!("Command {:?} executed successfully", cmd_str);
            },
            Ok(status) => {
                eprintln!("Команда {:?} завершилась с кодом {}", cmd_str, status);
                return HttpResponse::InternalServerError().body(format!("Команда {:?} завершилась с кодом {}", cmd_str, status));
            },
            Err(e) => {
                eprintln!("Ошибка выполнения команды {:?}: {}", cmd_str, e);
                return HttpResponse::InternalServerError().body(format!("Ошибка выполнения команды {:?}: {}", cmd_str, e));
            },
        }
    }

    HttpResponse::Ok().body("Драйвер WinDivert очищен")
}

// Функция для завершения запущенного процесса
async fn terminate(data: web::Data<Arc<AppState>>) -> impl Responder {
    println!("Received terminate request");

    let mut process_lock = match data.process.lock() {
        Ok(lock) => lock,
        Err(e) => {
            eprintln!("Mutex lock error: {}", e);
            return HttpResponse::InternalServerError().body("Internal Server Error");
        }
    };

    if let Some(child) = process_lock.as_mut() {
        match child.kill() {
            Ok(_) => {
                println!("Process terminated successfully");
                *process_lock = None;
                HttpResponse::Ok().body("Процесс завершен")
            },
            Err(e) => {
                eprintln!("Ошибка при завершении процесса: {}", e);
                HttpResponse::InternalServerError().body(format!("Ошибка при завершении процесса: {}", e))
            }
        }
    } else {
        println!("No running process to terminate");
        HttpResponse::BadRequest().body("Нет запущенных процессов")
    }
}

// Главная функция
#[actix_web::main]
async fn main() -> std::io::Result<()> {

    // Чтение настроек автозапуска из файла
    let mut auto_start_settings = AutoStartSettings {
        enabled: false,
        mode: None,
    };
    if let Ok(file) = fs::File::open("auto_start_settings.json") {
        if let Ok(settings) = serde_json::from_reader(file) {
            auto_start_settings = settings;
        }
    }

    // Инициализация глобального состояния
    let state = Arc::new(AppState {
        process: Mutex::new(None),
        auto_start_settings: Mutex::new(auto_start_settings),
    });

    // Запуск выбранного режима при автозапуске
    let auto_start = state.auto_start_settings.lock().unwrap().clone();

    if auto_start.enabled {
        if let Some(mode) = auto_start.mode {
            let req = web::Json(StartRequest { mode: mode });
            let state_clone = state.clone(); // Клонирование state здесь
            tokio::spawn(async move {
                start_fix(web::Data::new(state_clone), req).await; // Использование клона
            });
        }
    }

    println!("Server running at http://127.0.0.1:7684");

    HttpServer::new(move || {
        let state = state.clone(); // Клонируем state для каждого worker'a

        App::new()
            .app_data(web::Data::new(state))
            .route("/start", web::post().to(|data: web::Data<Arc<AppState>>, req: web::Json<StartRequest>| async move {
                start_fix(data, req).await
            }))
            .route("/clear-driver", web::post().to(|data: web::Data<Arc<AppState>>| async move {
                clear_driver(data).await
            }))
            .route("/terminate", web::post().to(|data: web::Data<Arc<AppState>>| async move {
                terminate(data).await
            }))
            .route("/auto-start-settings", web::get().to(|data: web::Data<Arc<AppState>>| async move {
                get_auto_start_settings(data).await
            }))
            .route("/auto-start-settings", web::post().to(|data: web::Data<Arc<AppState>>, req: web::Json<AutoStartSettings>| async move {
                set_auto_start_settings(data, req).await
            }))
    })
        .bind("127.0.0.1:7684")?
        .run()
        .await
}
```

python неправильно взаимодействует с сервером. Например, когда я пытаюсь запустить испрпвление, мне пишет:
```
Введите режим (general, beeline, mgts): general
Ошибка запроса к http://127.0.0.1:7684/start: Expecting value: line 1 column 1 (char 0)
Результат: None
```
Сделай рефакторинг кода на python, чтобы он был реализован просто в виде класса и функций
. Если проблема была и в rust, то исправь и ее. Я хочу, чтобы там было все равлизовано грамотно и отказоустойчиво