Моделирование симуляции потустороннего мира (создание приложения)

[MakarovDs]

И это вторая версия выбиратора случайных изображений

import os
import random
import time
import threading
import numpy as np
import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk

class ImageShuffler:
    def __init__(self, root):
        self.root = root
        self.root.title("Выбиратор случайных изображений")
        self.root.geometry("820x920")  # Размер для сетки

        # Поле для выбора папки
        self.select_folder_button = tk.Button(root, text="Выбрать папку", command=self.select_folder)
        self.select_folder_button.pack(pady=5)

        # Поле для настройки скорости
        self.speed_label = tk.Label(root, text="Скорость (сек):")
        self.speed_label.pack()
        self.speed_var = tk.DoubleVar(value=1.0)
        self.speed_entry = tk.Entry(root, textvariable=self.speed_var, width=5)
        self.speed_entry.pack()

        # Поле для количества изображений в ряду
        self.count_label = tk.Label(root, text="Количество изображений в ряду:")
        self.count_label.pack()
        self.count_var = tk.IntVar(value=5)
        self.count_entry = tk.Entry(root, textvariable=self.count_var, width=5)
        self.count_entry.pack()

        # Поле для количества рядов
        self.rows_label = tk.Label(root, text="Количество рядов:")
        self.rows_label.pack()
        self.rows_var = tk.IntVar(value=3)
        self.rows_entry = tk.Entry(root, textvariable=self.rows_var, width=5)
        self.rows_entry.pack()

        # Область для отображения изображений
        self.canvas = tk.Canvas(root, width=800, height=600, bg='white')
        self.canvas.pack(pady=10)

        # Кнопки "Запуск" и "Стоп"
        self.control_frame = tk.Frame(root)
        self.control_frame.pack(pady=5)

        self.start_button = tk.Button(self.control_frame, text="Запуск", command=self.start_shuffling)
        self.start_button.pack(side='left', padx=5)

        self.stop_button = tk.Button(self.control_frame, text="Стоп", command=self.stop_shuffling)
        self.stop_button.pack(side='left', padx=5)

        self.images = []
        self.thread = None
        self.running = False

    def load_image(self, image_path):
        """Загружает изображение с использованием Pillow и преобразует в массив NumPy."""
        try:
            img = Image.open(image_path)
            img = img.convert("RGB")
            return np.array(img)
        except Exception as e:
            print(f"Ошибка при загрузке изображения: {e}")
            return None

    def display_images(self, images):
        """Отображает изображения в виде сетки на канвасе, распределяя по рядам."""
        self.canvas.delete("all")
        width, height = 100, 100  # Размер каждого изображения
        spacing = 2  # Расстояние между изображениями

        count_rows = self.rows_var.get()
        total_images = len(images)
        images_per_row = total_images // count_rows
        remainder = total_images % count_rows

        index = 0
        self.canvas.images = []  # Обнуляем список ссылок
        for row in range(count_rows):
            count_in_this_row = images_per_row + (1 if row < remainder else 0)
            for col in range(count_in_this_row):
                if index >= total_images:
                    break
                img = images[index]
                if img is not None:
                    pil_img = Image.fromarray(img)
                    pil_img = pil_img.resize((width, height))
                    img_tk = ImageTk.PhotoImage(pil_img)
                    x = col * (width + spacing)
                    y = row * (height + spacing)
                    self.canvas.create_image(x, y, anchor='nw', image=img_tk)
                    self.canvas.images.append(img_tk)
                index += 1

    def shuffle_display_images(self, images):
        """Обновляет изображения в виде сетки с заданной скоростью."""
        self.running = True
        while self.running:
            total_images = self.count_var.get() * self.rows_var.get()
            selected_images = []
            for _ in range(total_images):
                img_path = random.choice(images)
                image = self.load_image(img_path)
                selected_images.append(image)
            self.display_images(selected_images)
            time.sleep(self.speed_var.get())

    def start_shuffling(self):
        """Запускает поток ретрансляции изображений."""
        if self.thread and self.thread.is_alive():
            self.running = False
            self.thread.join()
        if self.images:
            self.thread = threading.Thread(target=self.shuffle_display_images, args=(self.images,), daemon=True)
            self.thread.start()

    def stop_shuffling(self):
        """Останавливает поток ретрансляции изображений."""
        self.running = False
        if self.thread and self.thread.is_alive():
            self.thread.join()

    def select_folder(self):
        """Выбор папки и автоматический запуск ретрансляции."""
        folder_path = filedialog.askdirectory(title="Выберите папку")
        if folder_path:
            self.images = [os.path.join(folder_path, f) for f in os.listdir(folder_path)
                           if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif'))]
            if self.images:
                self.start_shuffling()
            else:
                print("В выбранной папке нет изображений.")

# Создание интерфейса
root = tk.Tk()
app = ImageShuffler(root)

# Запуск интерфейса
root.mainloop()

Ссылка на гитхаб -> github.



Как вариант можно сделать изображения всех букв алфавита, и попытаться таким образом получить какой-то ответ с того света.

[MakarovDs]

Хотел сделать мгновенный режим но больше нет желания ебаться с этим говном выбиратора.. Да, и нет у меня такой цели...

import os
import random
import threading
import time
import numpy as np
import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk

class ImageDisplayWindow(tk.Toplevel):
    def __init__(self, master):
        super().__init__(master)
        self.title("Облако изображений")
        self.canvas = tk.Canvas(self, width=800, height=600, bg='white')
        self.canvas.pack()
        self.images_tk = []

    def show_images(self, images, rows):
        self.canvas.delete("all")
        width, height = 100, 100
        spacing = 2
        total_images = len(images)
        images_per_row = total_images // rows
        remainder = total_images % rows
        index = 0
        self.images_tk.clear()
        for row in range(rows):
            count_in_row = images_per_row + (1 if row < remainder else 0)
            for col in range(count_in_row):
                if index >= total_images:
                    break
                img = images[index]
                if img is not None:
                    pil_img = Image.fromarray(img)
                    pil_img = pil_img.resize((width, height))
                    img_tk = ImageTk.PhotoImage(pil_img)
                    x = col * (width + spacing)
                    y = row * (height + spacing)
                    self.canvas.create_image(x, y, anchor='nw', image=img_tk)
                    self.images_tk.append(img_tk)
                index += 1

class ImageShuffler:
    def __init__(self, root):
        self.root = root
        self.root.title("Управление изображениями")
        self.images = []
        self.display_window = None
        self.thread = None
        self.running = False
        self.auto_mode = False  # флаг для автоматического режима

        # Управление
        tk.Button(root, text="Выбрать папку", command=self.select_folder).pack(pady=5)

        self.speed_var = tk.StringVar(value="1.0")
        tk.Label(root, text="Скорость (сек):").pack()
        tk.Entry(root, textvariable=self.speed_var, width=5).pack()

        tk.Label(root, text="Количество изображений в ряду:").pack()
        self.count_var = tk.IntVar(value=5)
        tk.Entry(root, textvariable=self.count_var, width=5).pack()

        tk.Label(root, text="Количество рядов:").pack()
        self.rows_var = tk.IntVar(value=3)
        tk.Entry(root, textvariable=self.rows_var, width=5).pack()

        # Режимы
        self.mode_frame = tk.Frame(root)
        self.mode_frame.pack(pady=5)
        self.mode_var = tk.StringVar(value="instant")
        tk.Radiobutton(self.mode_frame, text="Мгновенно", variable=self.mode_var, value="instant").pack(side='left', padx=5)
        tk.Radiobutton(self.mode_frame, text="Поочередно", variable=self.mode_var, value="sequential").pack(side='left', padx=5)

        # Кнопки
        control_frame = tk.Frame(root)
        control_frame.pack(pady=5)
        tk.Button(control_frame, text="Запуск", command=self.start).pack(side='left', padx=5)
        tk.Button(control_frame, text="Стоп", command=self.stop).pack(side='left', padx=5)
        tk.Button(control_frame, text="Открыть окно изображений", command=self.open_display_window).pack(side='left', padx=5)

    def select_folder(self):
        folder = filedialog.askdirectory(title="Выберите папку")
        if folder:
            self.images = [os.path.join(folder, f) for f in os.listdir(folder)
                           if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif'))]
            if self.images:
                self.start()

    def open_display_window(self):
        if self.display_window is None or not self.display_window.winfo_exists():
            self.display_window = ImageDisplayWindow(self.root)

    def load_image(self, path):
        try:
            img = Image.open(path)
            img = img.convert("RGB")
            return np.array(img)
        except:
            return None

    def update_images(self, images):
        if self.display_window and self.display_window.winfo_exists():
            rows = self.rows_var.get()
            self.display_window.show_images(images, rows)

    def run_instant_mode(self):
        total = self.count_var.get() * self.rows_var.get()
        imgs = []
        for _ in range(total):
            path = random.choice(self.images)
            img = self.load_image(path)
            imgs.append(img)
        self.update_images(imgs)

    def run_sequential_mode(self):
        self.running = True
        while self.running:
            total = self.count_var.get() * self.rows_var.get()
            imgs = []
            for _ in range(total):
                path = random.choice(self.images)
                img = self.load_image(path)
                imgs.append(img)
            self.update_images(imgs)
            try:
                speed = float(self.speed_var.get())
                if speed <= 0:
                    speed = 0.1
            except:
                speed = 1.0
            time.sleep(speed)

    def auto_instant_mode(self):
        """Автоматически обновлять изображения через интервал."""
        self.auto_mode = True
        while self.auto_mode:
            self.run_instant_mode()
            try:
                speed = float(self.speed_var.get())
                if speed <= 0:
                    speed = 0.1
            except:
                speed = 1.0
            time.sleep(speed)

    def start(self):
        self.stop()
        if not self.images:
            return
        mode = self.mode_var.get()
        if mode == "instant":
            # Запускаем автоматический цикл
            self.auto_mode = True
            self.thread = threading.Thread(target=self.auto_instant_mode, daemon=True)
            self.thread.start()
        else:
            # Запускаем поочередное обновление
            self.thread = threading.Thread(target=self.run_sequential_mode, daemon=True)
            self.thread.start()

    def stop(self):
        self.auto_mode = False
        self.running = False
        if hasattr(self, 'thread') and self.thread and self.thread.is_alive():
            self.thread.join()

def change_mode(self):
    # при смене режима, если выбран "Мгновенно", автоматически запускать цикл
    if self.mode_var.get() == "instant":
        self.start()
    else:
        self.stop()

# Создаем окно
root = tk.Tk()
app = ImageShuffler(root)
root.mainloop()

Может есть у кого какие идеи как решить эту проблему...

[MakarovDs]

Седьмая версия ЭГФ Хоруса - Просто лютейшая бомба от Gemeni ! Такого ЭГФ я ещё не встречал!

import tkinter as tk
from tkinter import filedialog
import os
import random

def convert_video_to_bytes(path):
    with open(path, 'rb') as file:
        return file.read()

def bytes_to_video(byte_data, duration_minutes):
    output_path = os.path.join(os.path.expanduser("~"), "Desktop", f"undefined_{duration_minutes}.mp4")
    with open(output_path, 'wb') as file:
        file.write(byte_data)

def select_video_to_bytes():
    file_path = filedialog.askopenfilename(title="Выберите видео файл")
    if file_path:
        byte_data = convert_video_to_bytes(file_path)
        byte_list = list(byte_data)

        key_length = 100  # Длина ключевой части (например, заголовок)
        data_to_shuffle_start = key_length
        data_to_shuffle_end = len(byte_list)

        # Перемешиваем только 10% от остальной части
        to_shuffle = byte_list[data_to_shuffle_start:data_to_shuffle_end]
        num_bytes_to_shuffle = max(1, len(to_shuffle) // 10)  # Перемешиваем 10%
        
        # Выбираем случайные байты для перемешивания
        indices_to_shuffle = random.sample(range(len(to_shuffle)), num_bytes_to_shuffle)
        shuffled_section = [to_shuffle[i] for i in indices_to_shuffle]
        random.shuffle(shuffled_section)

        for i, index in enumerate(indices_to_shuffle):
            to_shuffle[index] = shuffled_section[i]

        # Объединяем перемешанные и неперемешанные байты
        shuffled_byte_data = byte_list[:data_to_shuffle_start] + to_shuffle
        
        # Преобразование обратно в байты
        shuffled_byte_data = bytes(shuffled_byte_data)
        text_file_path = os.path.join(os.path.expanduser("~"), "Desktop", "video_bytes.txt")
        with open(text_file_path, 'wb') as text_file:  # Changed 'w' to 'wb'
            text_file.write(shuffled_byte_data)  # Write bytes directly
        print(f"Байты видео сохранены в: {text_file_path}")


def select_bytes_to_video():
    file_path = filedialog.askopenfilename(title="Выберите текстовый файл с байтами")
    if file_path:
        with open(file_path, 'rb') as text_file:  # Changed 'r' to 'rb'
            byte_data = text_file.read()  # Read as bytes
        duration_minutes = 10  # Задайте длительность видео в минутах
        bytes_to_video(byte_data, duration_minutes)
        print(f"Видео создано на рабочем столе с именем: undefined_{duration_minutes}.mp4")


def convert_video_to_ef():
    """Комбинированная функция: видео -> байты -> видео"""
    file_path = filedialog.askopenfilename(title="Выберите видео файл для преобразования в ЭГФ")
    if file_path:
        # Шаг 1: Видео в байты
        byte_data = convert_video_to_bytes(file_path)
        byte_list = list(byte_data)

        key_length = 100
        data_to_shuffle_start = key_length
        data_to_shuffle_end = len(byte_list)

        # Перемешиваем 10% данных
        to_shuffle = byte_list[data_to_shuffle_start:data_to_shuffle_end]
        num_bytes_to_shuffle = max(1, len(to_shuffle) // 10)
        indices_to_shuffle = random.sample(range(len(to_shuffle)), num_bytes_to_shuffle)
        shuffled_section = [to_shuffle[i] for i in indices_to_shuffle]
        random.shuffle(shuffled_section)

        for i, index in enumerate(indices_to_shuffle):
            to_shuffle[index] = shuffled_section[i]

        # Объединяем
        byte_list[:data_to_shuffle_start] = byte_list[:data_to_shuffle_start]
        byte_list[data_to_shuffle_start:data_to_shuffle_end] = to_shuffle
        shuffled_byte_data = bytes(byte_list)

        # Шаг 2: байты обратно в видео
        output_path = os.path.join(os.path.expanduser("~"), "Desktop", "evp_video.mp4")
        with open(output_path, 'wb') as f:
            f.write(shuffled_byte_data)
        print(f"Видео в формате ЭГФ сохранено: {output_path}")


def bytes_to_binary_string(byte_data):
    """Преобразует байты в строку из 0 и 1."""
    binary_string = ''.join(format(byte, '08b') for byte in byte_data)
    return binary_string

def binary_string_to_bytes(binary_string):
    """Преобразует строку из 0 и 1 обратно в байты."""
    byte_list = []
    for i in range(0, len(binary_string), 8):
        byte_string = binary_string[i:i+8]
        byte = int(byte_string, 2)
        byte_list.append(byte)
    return bytes(byte_list)


def convert_bytes_to_binary_file():
    file_path = filedialog.askopenfilename(title="Выберите текстовый файл с байтами")
    if file_path:
        try:
            with open(file_path, 'rb') as byte_file: # Read the file as bytes
                byte_data = byte_file.read()
            binary_string = bytes_to_binary_string(byte_data)
            output_path = os.path.join(os.path.expanduser("~"), "Desktop", "video_binary.txt")
            with open(output_path, 'w') as binary_file:
                binary_file.write(binary_string)
            print(f"Двоичный код сохранен в: {output_path}")
        except Exception as e:
            print(f"Ошибка при преобразовании в двоичный код: {e}")


def convert_binary_file_to_bytes():
    file_path = filedialog.askopenfilename(title="Выберите текстовый файл с двоичным кодом")
    if file_path:
        try:
            with open(file_path, 'r') as binary_file:
                binary_string = binary_file.read()
            byte_data = binary_string_to_bytes(binary_string)
            output_path = os.path.join(os.path.expanduser("~"), "Desktop", "video_bytes_restored.txt")
            with open(output_path, 'wb') as byte_file: # Write the bytes back
                byte_file.write(byte_data)
            print(f"Байты восстановлены и сохранены в: {output_path}")
        except Exception as e:
            print(f"Ошибка при восстановлении байтов: {e}")



# Создание графического интерфейса
root = tk.Tk()
root.title("Конвертер видео")
root.geometry("350x260") 

video_to_bytes_button = tk.Button(root, text="Видео в текст", command=select_video_to_bytes)
video_to_bytes_button.pack(pady=5)

bytes_to_video_button = tk.Button(root, text="Текст в видео", command=select_bytes_to_video)
bytes_to_video_button.pack(pady=5)

convert_to_ef_button = tk.Button(root, text="Превратить видео в ЭГФ", command=convert_video_to_ef)
convert_to_ef_button.pack(pady=5)

# Новые кнопки для преобразования в двоичный код и обратно
bytes_to_binary_button = tk.Button(root, text="Текст байтов в 0 и 1", command=convert_bytes_to_binary_file)
bytes_to_binary_button.pack(pady=5)

binary_to_bytes_button = tk.Button(root, text="Текст 0 и 1 в текст байтов", command=convert_binary_file_to_bytes)
binary_to_bytes_button.pack(pady=5)


# Запуск интерфейса
root.mainloop()

Код Github там же и пример.

[MakarovDs]

Можно в принципе сделать онлайн версию выбиратора случайных изображений:

Ссылка

[MakarovDs]

Короче херня эта версия с папкой лучше просто сделать много разных URL картинок, и пускай случайно выбираются.

Выбиратор случайных изображений 2

[MakarovDs]

Херь опять получилась картинки отображаются в разных местах исправим это недоразумение.

Выбиратор случайных изображений 3

[MakarovDs]

Я кстати починил все скрипты для EVP на WebSDR теперь enter сам нажимается автоматический, и добавил ещё множество разных скриптов если кому интересно -> WebSDR-EVP github

[MakarovDs]

Я думаю... Я думаю... Я... И ничего опять не придумаю...
Кто-то на балконе повис!
Кто-то быстро вверх потом вниз!
Я пока рисую мосты а ты, а ты, а кто ты!?
Кто-то на балконе повисссс!
Кто-то быстро вверх потом внииизз!
Я организую мосты! А ты, а ты, а кто ты!?

[MakarovDs]

И эта 8 версия ЭГФ Хоруса которая является продолжением 7 версии только теперь можно делать из множества файлов а не только из 1 файла ЭГФ, конвертировать в кашу байтов, 0, и 1.

import tkinter as tk
from tkinter import filedialog, messagebox
import os
import random
from moviepy.editor import VideoFileClip

# Глобальный список выбранных файлов
selected_files = []

# -------------------------
# Вспомогательные функции
# -------------------------

def convert_video_to_bytes(path):
    """Читает файл и возвращает его байты."""
    with open(path, 'rb') as file:
        return file.read()

def bytes_to_video(byte_data, duration_minutes):
    """Сохраняет байты как mp4 на рабочий стол с именем undefined_{duration_minutes}.mp4"""
    output_path = os.path.join(os.path.expanduser("~"), "Desktop", f"undefined_{duration_minutes}.mp4")
    with open(output_path, 'wb') as file:
        file.write(byte_data)
    return output_path

def extract_audio_from_video(video_path):
    """Извлекает аудио дорожку из видео и возвращает путь к временному mp3 файлу."""
    try:
        clip = VideoFileClip(video_path)
        audio_path = os.path.splitext(video_path)[0] + "_temp_audio.mp3"
        clip.audio.write_audiofile(audio_path, verbose=False, logger=None)
        clip.close()
        return audio_path
    except Exception as e:
        messagebox.showerror("Ошибка", f"Не удалось извлечь аудио из видео: {e}")
        return None

def convert_audio_to_bytes(path):
    with open(path, 'rb') as f:
        return f.read()

def save_bytes_as_audio(byte_data, output_path):
    with open(output_path, 'wb') as f:
        f.write(byte_data)

# -------------------------
# Основные операции
# -------------------------

def select_files():
    """Выбрать несколько файлов и добавить в список."""
    global selected_files
    file_paths = filedialog.askopenfilenames(
        title="Выберите файлы",
        filetypes=[("Аудио и видео файлы", "*.mp3;*.wav;*.ogg;*.mp4;*.avi;*.mov;*.mkv"),
                   ("Все файлы", "*.*")]
    )
    if file_paths:
        for path in file_paths:
            if path not in selected_files:
                selected_files.append(path)
                listbox.insert(tk.END, path)

def remove_selected():
    """Удалить выделенные элементы из списка."""
    global selected_files
    selected_indices = listbox.curselection()
    if not selected_indices:
        messagebox.showwarning("Предупреждение", "Выберите файл(ы) для удаления.")
        return
    for index in reversed(selected_indices):
        listbox.delete(index)
        del selected_files[index]

def select_videos_to_bytes_multiple():
    """
    Обрабатывает все файлы из selected_files: для каждого файла
    читаем байты, частично перемешиваем (не трогаем header) и
    добавляем в общий поток байтов. Сохраняем один файл на Desktop.
    """
    if not selected_files:
        messagebox.showwarning("Предупреждение", "Сначала выберите файлы.")
        return

    try:
        combined_bytes = bytearray()
        key_length = 100  # не трогаем первые 100 байт в каждом файле

        for file_path in selected_files:
            # Берём исходные байты файла (видео или аудио — просто читаем файл)
            try:
                byte_data = convert_video_to_bytes(file_path)
            except Exception as e:
                messagebox.showwarning("Предупреждение", f"Не удалось прочитать {file_path}: {e}")
                continue

            byte_list = list(byte_data)
            if len(byte_list) > key_length + 1:
                data_to_shuffle_start = key_length
                data_to_shuffle_end = len(byte_list)
                to_shuffle = byte_list[data_to_shuffle_start:data_to_shuffle_end]

                # Перемешиваем 10% оставшихся байтов (но минимум 1)
                num_bytes_to_shuffle = max(1, len(to_shuffle) // 10)
                indices_to_shuffle = random.sample(range(len(to_shuffle)), num_bytes_to_shuffle)

                shuffled_section = [to_shuffle[i] for i in indices_to_shuffle]
                random.shuffle(shuffled_section)
                for i, index in enumerate(indices_to_shuffle):
                    to_shuffle[index] = shuffled_section[i]

                # Собираем обратно
                byte_list[data_to_shuffle_start:data_to_shuffle_end] = to_shuffle

            # Добавляем обработанный файл в общий буфер
            combined_bytes.extend(byte_list)

        # Сохраняем объединённые байты в один бинарный файл на рабочий стол
        output_path = os.path.join(os.path.expanduser("~"), "Desktop", "combined_video_bytes.bin")
        with open(output_path, 'wb') as out_f:
            out_f.write(bytes(combined_bytes))

        messagebox.showinfo("Готово", f"Байты всех выбранных файлов сохранены в: {output_path}")

    except Exception as e:
        messagebox.showerror("Ошибка", f"Ошибка при обработке файлов: {e}")

def select_bytes_to_video():
    """Выбрать файл с байтами и сохранить как видео (измените duration_minutes при необходимости)."""
    file_path = filedialog.askopenfilename(title="Выберите файл с байтами", filetypes=[("Все файлы", "*.*")])
    if not file_path:
        return
    try:
        with open(file_path, 'rb') as text_file:
            byte_data = text_file.read()
        duration_minutes = 10  # задайте желаемую длительность
        out_path = bytes_to_video(byte_data, duration_minutes)
        messagebox.showinfo("Готово", f"Видео создано: {out_path}")
    except Exception as e:
        messagebox.showerror("Ошибка", f"Ошибка при создании видео: {e}")

def convert_video_to_ef_single():
    """Обработка одного видео файла: преобразование в ЭГФ (shuffle) и сохранение."""
    file_path = filedialog.askopenfilename(title="Выберите видео файл для преобразования в ЭГФ")
    if not file_path:
        return
    try:
        byte_data = convert_video_to_bytes(file_path)
        byte_list = list(byte_data)
        key_length = 100
        data_to_shuffle_start = key_length
        data_to_shuffle_end = len(byte_list)
        to_shuffle = byte_list[data_to_shuffle_start:data_to_shuffle_end]
        num_bytes_to_shuffle = max(1, len(to_shuffle) // 10)
        indices_to_shuffle = random.sample(range(len(to_shuffle)), num_bytes_to_shuffle)
        shuffled_section = [to_shuffle[i] for i in indices_to_shuffle]
        random.shuffle(shuffled_section)
        for i, index in enumerate(indices_to_shuffle):
            to_shuffle[index] = shuffled_section[i]
        byte_list[data_to_shuffle_start:data_to_shuffle_end] = to_shuffle
        shuffled_byte_data = bytes(byte_list)
        output_path = os.path.join(os.path.expanduser("~"), "Desktop", "evp_video.mp4")
        with open(output_path, 'wb') as f:
            f.write(shuffled_byte_data)
        messagebox.showinfo("Готово", f"Видео в формате ЭГФ сохранено: {output_path}")
    except Exception as e:
        messagebox.showerror("Ошибка", f"Ошибка при преобразовании: {e}")

Короче слишком огромный файл вот ссылка на гитхаб -> github link.



Вообщем я верной дорогой иду просто сделал зигзаг не туда но потом понял.