לא חושב לנסות לחקות את אליעזר סילבר @es0583292679 האלוף!..
רעיון השם היה משום שנמאס לי שמתביישים במושגים שיש לנו
קצת ויגבה ליבו!
ואם פיתחתי תוכנה לציבור יראי ה' למה ששם התוכנה לא יתחבר אליהם?
אה.. וגם השפה החדשה..

נוצר עם הגירסה הבאה של 'תופס תמורתו'

TofesTmurato 1v

לא לצחוק על הטריק של השפה... אני לא מתכנת!

# -*- coding: utf-8 -*-
import sys, os, threading, json, tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image
import customtkinter as ctk

try:
    from moviepy.editor import VideoFileClip, AudioFileClip
except Exception:
    print("Missing moviepy. Install with: pip install moviepy")
    sys.exit(1)

def resource_path(relative_path):
    try:
        base_path = sys._MEIPASS
    except Exception:
        base_path = os.path.abspath(".")
    return os.path.join(base_path, relative_path)

SETTINGS_FILE = os.path.join(os.getenv('APPDATA', os.path.expanduser('~')), 'tmurato_settings.json')

MEDIA_TYPES = {
    'Video': ['MP4', 'GIF', 'MOV', 'MKV', 'WEBM', 'AVI'],
    'Audio': ['MP3', 'WAV', 'M4A', 'FLAC', 'AAC'],
    'Image': ['JPG', 'JPEG', 'PNG', 'WEBP', 'PDF', 'ICO', 'BMP']
}

TRANSLATIONS = {
    'עברית': {
        'title': 'תופס תמורתו - ממיר מקצועי', 'select': 'קבצים בחר', 'convert': 'הכל המר',
        'low': 'נמוכה', 'med': 'בינונית', 'high': 'גבוהה', 'original': 'מקור',
        'files_sel': 'נבחרו {} קבצים', 'done': '!בסייעתא דשמייא ההמרה הסתיימה בהצלחה', 
        'type': ':הקובץ סוג', 'fmt': ':פורמט', 'out_folder': 'קבצים שהומרו'
    },
    'English': {
        'title': 'Tofes Tmurato - Converter', 'select': 'Select Files', 'convert': 'Convert All',
        'low': 'Low', 'med': 'Med', 'high': 'High', 'original': 'Original',
        'files_sel': '{} files selected', 'done': 'Done!', 
        'type': 'Type:', 'fmt': 'Format:', 'out_folder': 'Converted files'
    },
    'יידיש': {
        'title': 'תופס תמורתו - מעדיאַ קאָנוערטער', 'select': 'קלייַבן טעקעס', 'convert': 'קאָנווערט אַלץ',
        'low': 'נידעריק', 'med': 'מיטל', 'high': 'הויך', 'original': 'מקור',
        'files_sel': '{} טעקעס אויסגעקליבן', 'done': '!בסייעתא דשמייא געענדיקט הצלחה', 
        'type': 'טיפּ', 'fmt': 'פֿאָרמאַט', 'out_folder': 'קאָנווערטירטע טעקעס'
    },
    'ארמית': {
        'title': 'תופס תמורתו - מחלף זמניא', 'select': 'מניינא גבי', 'convert': 'כולא חלף',
        'low': 'זוטא', 'med': 'ממוצע', 'high': 'רבא', 'original': 'עיקרא',
        'files_sel': 'גבייתא {} מניינין', 'done': '!בסייעתא דשמייא חילוף זמניא אשתלם שפיר', 
        'type': ':זניא', 'fmt': ':טופסא', 'out_folder': 'מניינין דאשתני'
    }
}

class ConverterApp(ctk.CTk):
    def __init__(self):
        super().__init__()
        self.file_paths = []
        self.settings = self.load_settings()
        
        icon_path = resource_path("icon.ico")
        if os.path.exists(icon_path):
            self.iconbitmap(icon_path)
            self.after(200, lambda: self.iconbitmap(icon_path))

        saved_lang = self.settings.get('lang', 'עברית')
        self.lang = saved_lang if saved_lang in TRANSLATIONS else 'עברית'
        
        self.setup_ui()
        self.apply_saved_settings()

    def load_settings(self):
        if os.path.exists(SETTINGS_FILE):
            try:
                with open(SETTINGS_FILE, 'r') as f: return json.load(f)
            except: pass
        return {'lang': 'עברית'}

    def save_settings(self):
        self.settings.update({
            'lang': self.lang, 'quality': self.seg_quality.get(), 
            'mtype': self.opt_type.get(), 'fmt': self.opt_fmt.get(), 
            'theme': ctk.get_appearance_mode()
        })
        with open(SETTINGS_FILE, 'w') as f: json.dump(self.settings, f)

    def apply_saved_settings(self):
        self.change_lang(self.lang)
        self.opt_type.set(self.settings.get('mtype', 'Video'))
        self.update_formats(self.opt_type.get())
        self.opt_fmt.set(self.settings.get('fmt', 'MP4'))
        if 'theme' in self.settings: ctk.set_appearance_mode(self.settings['theme'])

    def setup_ui(self):
        self.geometry("450x650")
        self.title("Tofes Tmurato 1.7")
        
        self.header = ctk.CTkFrame(self, fg_color="transparent")
        self.header.pack(pady=10, fill="x", padx=20)
        
        self.theme_btn = ctk.CTkButton(self.header, text="🌓", width=40, command=self.toggle_theme)
        self.theme_btn.pack(side="left")
        
        self.lang_menu = ctk.CTkOptionMenu(self.header, values=list(TRANSLATIONS.keys()), command=self.change_lang, width=100)
        self.lang_menu.pack(side="right")

        self.lbl_title = ctk.CTkLabel(self, text="", font=("Arial", 22, "bold"))
        self.lbl_title.pack(pady=10)

        self.btn_select = ctk.CTkButton(self, text="", command=self.select_files)
        self.btn_select.pack(pady=10)

        self.lbl_count = ctk.CTkLabel(self, text="", font=("Arial", 14))
        self.lbl_count.pack(pady=5)

        self.sett_frame = ctk.CTkFrame(self)
        self.sett_frame.pack(pady=10, padx=30, fill="both")

        self.lbl_type = ctk.CTkLabel(self.sett_frame, text="")
        self.lbl_type.pack()
        self.opt_type = ctk.CTkOptionMenu(self.sett_frame, values=list(MEDIA_TYPES.keys()), command=self.update_formats)
        self.opt_type.pack(pady=5)

        self.lbl_fmt = ctk.CTkLabel(self.sett_frame, text="")
        self.lbl_fmt.pack()
        self.opt_fmt = ctk.CTkOptionMenu(self.sett_frame, values=[])
        self.opt_fmt.pack(pady=5)

        self.seg_quality = ctk.CTkSegmentedButton(self.sett_frame)
        self.seg_quality.pack(pady=20, padx=10, fill="x")

        self.progress_bar = ctk.CTkProgressBar(self)
        self.progress_bar.pack(pady=10, padx=50, fill="x")
        self.progress_bar.set(0)

        self.btn_convert = ctk.CTkButton(self, text="", fg_color="#28a745", command=self.start_conversion, height=45)
        self.btn_convert.pack(pady=20)

    def toggle_theme(self):
        new_mode = "light" if ctk.get_appearance_mode() == "Dark" else "dark"
        ctk.set_appearance_mode(new_mode)
        self.save_settings()

    def change_lang(self, v):
        self.lang = v
        t = TRANSLATIONS[v]
        self.lbl_title.configure(text=t['title'])
        self.btn_select.configure(text=t['select'])
        self.lbl_type.configure(text=t['type'])
        self.lbl_fmt.configure(text=t['fmt'])
        self.btn_convert.configure(text=t['convert'])
        
        q_map = {"low": t['low'], "med": t['med'], "high": t['high'], "original": t['original']}
        self.seg_quality.configure(values=list(q_map.values()))
        self.seg_quality.set(t['original'])
        
        self.update_count_label()
        self.save_settings()

    def update_count_label(self):
        t = TRANSLATIONS[self.lang]
        self.lbl_count.configure(text=t['files_sel'].format(len(self.file_paths)))

    def update_formats(self, mtype):
        self.opt_fmt.configure(values=MEDIA_TYPES[mtype])
        self.opt_fmt.set(MEDIA_TYPES[mtype][0])
        self.save_settings()

    def select_files(self):
        paths = filedialog.askopenfilenames()
        if paths:
            self.file_paths = list(paths)
            self.update_count_label()
            
            ext = os.path.splitext(paths[0])[1][1:].upper()
            for mtype, exts in MEDIA_TYPES.items():
                if ext in exts or (ext == 'JPG' and 'JPEG' in exts):
                    self.opt_type.set(mtype)
                    self.update_formats(mtype)
                    break

    def start_conversion(self):
        if not self.file_paths: return
        self.save_settings()
        self.btn_convert.configure(state="disabled")
        threading.Thread(target=self.run_process, daemon=True).start()

    def run_process(self):
        for i, path in enumerate(self.file_paths):
            self.convert_logic(path)
            self.progress_bar.set((i + 1) / len(self.file_paths))
        self.btn_convert.configure(state="normal")
        self.after(0, lambda: messagebox.showinfo("V", TRANSLATIONS[self.lang]['done']))

    def convert_logic(self, in_p):
        ext = self.opt_fmt.get().lower()
        mtype = self.opt_type.get()
        
        source_dir = os.path.dirname(in_p)
        folder_name = TRANSLATIONS[self.lang]['out_folder']
        target_dir = os.path.join(source_dir, folder_name)
        
        if not os.path.exists(target_dir):
            os.makedirs(target_dir)
            
        out_p = os.path.join(target_dir, f"{os.path.splitext(os.path.basename(in_p))[0]}.{ext}")
        
        # זיהוי רמת האיכות שנבחרה
        t = TRANSLATIONS[self.lang]
        q_val = self.seg_quality.get()
        q_key = next((k for k in ['low', 'med', 'high', 'original'] if t[k] == q_val), 'original')
        
        # הגדרות פרמטרים לפי רמה
        q_cfg = {
            'low':      {'img': 30, 'vid': '600k',  'aud': '64k'},
            'med':      {'img': 60, 'vid': '1500k', 'aud': '128k'},
            'high':     {'img': 85, 'vid': '4000k', 'aud': '256k'},
            'original': {'img': 95, 'vid': None,    'aud': None}
        }[q_key]

        try:
            if mtype == 'Image':
                with Image.open(in_p) as img:
                    if ext in ['jpg', 'jpeg'] and img.mode in ("RGBA", "P"):
                        img = img.convert("RGB")
                    if ext == 'pdf': img.convert("RGB").save(out_p, "PDF")
                    else: img.save(out_p, quality=q_cfg['img'], optimize=True)
            elif mtype == 'Video':
                with VideoFileClip(in_p) as clip:
                    params = {"codec": "libx264", "logger": None}
                    if q_cfg['vid']: params["bitrate"] = q_cfg['vid']
                    clip.write_videofile(out_p, **params)
            elif mtype == 'Audio':
                with AudioFileClip(in_p) as clip:
                    params = {"logger": None}
                    if q_cfg['aud']: params["bitrate"] = q_cfg['aud']
                    clip.write_audiofile(out_p, **params)
        except Exception as e: print(f"Error: {e}")

if __name__ == "__main__":
    app = ConverterApp()
    app.mainloop()