בקשה | המרת ספר בAI אנא פורמט

[חד בדרא השני]

אני זקוק להמיר ספר ישן אשמח אם מישהוי יוכל להדריך אותי באיזה מודל הכי טוב, באיזה דרך, ומה פברובט המדויק לכתוב לו שיוציא מדויק ולא להמציא, והאם יש צורך לתת לו את ההמרה של ABBYY FineReader PDF

זה הספרהר אפרים מסימן ח.pdf

[123 דג מלוח]

@חד-בדרא-השני אתה מתכוון לOCR?
הפורום מפוצץ חומר בענין.
מהיכ"ת שצריך דוקא מודל צ'אט?

[חד בדרא השני]

@123-דג-מלוח אחרי המרה צריך מישהו שיתקן את השגיאות ואין כמו AI כמו שמפוצך בפורום

ניסתי באתר-במודל שבנה הרה"ג @לא-מתייאש אבל הוא לא הצליח אולי המפתח שהבאתי מהבית:) לא היה טוב מספיק...

[רציונל]

@חד-בדרא-השני אם זה ספר שלא משובש מאוד, ג'מיני פלאש לייט מאוד טוב בזה. ( יש לך 500 קריאות חינמיות ביום) תשלח עמוד עמוד בעזרת סקריפט קצר מה ai הקרוב למקום מגוריך.

[חד בדרא השני]

@רציונל שו הדא?
תסביר לי ויתר אם אפשר בבקשה..

[רציונל]

@חד-בדרא-השני אין לי עכשיו זמן, אכתוב בקצרה ואם תצטרך ארחיב מחר.
תוציא מפתח api חינמי מג'מיני
בקריאה תקרא לג'מיני פלאש לייט
תעשה ( או ש ai יעשה לך) סקריפט שיפרק את ה pdf עמוד עמוד וישלח כתמונה לג'מיני עם הנחיה קשיחה שלא להוסיף דבר ולא לנחש אלא לשמש כרובוט תקבל בחזרה את הפלט וזהו

[רציונל]

הדרכה מעט יותר מפורטת
תוציא מפתח API חינמי מפה https://aistudio.google.com/app/apikey
אם אין לך פייתון תתקין
תתקין את

pip install PyMuPDF opencv-python numpy EbookLib pillow google-genai

צור קובץ עם סיומת PY ושמור בו את הסקריפט בהמשך
תריץ את הסקריפט (לא מתחייב שאין בו באגים, לקחתי סקריפט שהשתמשתי איתו ושיפרתי לו באמצעות AI את חויית המשתמש אני מקווה שהוא לא הוסיף משלו )

import os
import sys
import time
import re
import shutil
import concurrent.futures
from uuid import uuid4

# ==============================================================================
# שלב 1: בדיקה שכל הספריות מותקנות (ידידותי למשתמש)
# ==============================================================================
try:
    import fitz  # PyMuPDF
    import cv2
    import numpy as np
    from ebooklib import epub, ITEM_IMAGE
    from google import genai
    from google.genai import types
    from PIL import Image
except ImportError as e:
    print("❌ חסרים רכיבים להרצת התוכנה!")
    print("כדי להתקין אותם, פתח את שורת הפקודה (CMD או Terminal) והדבק את הפקודה הבאה:")
    print("\npip install PyMuPDF opencv-python numpy EbookLib pillow google-genai\n")
    input("לאחר ההתקנה, לחץ אנטר כדי לצאת ונסה להריץ שוב...")
    sys.exit()

# ==============================================================================
# שלב 2: הגדרת סביבת העבודה (תיקיות הקלט והפלט)
# ==============================================================================
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
INPUT_DIR = os.path.join(BASE_DIR, "input_books")
OUTPUT_DIR = os.path.join(BASE_DIR, "output_books")
KEY_FILE = os.path.join(BASE_DIR, "api_key.txt")

os.makedirs(INPUT_DIR, exist_ok=True)
os.makedirs(OUTPUT_DIR, exist_ok=True)

def log(msg): 
    print(msg, flush=True)

# ==============================================================================
# שלב 3: ניהול מפתח API ותפריט למשתמש
# ==============================================================================
print("========================================")
print(" ברוכים הבאים לממיר הספרים החכם של Gemini")
print("========================================\n")

# בדיקה אם יש מפתח API שמור
API_KEY = ""
if os.path.exists(KEY_FILE):
    with open(KEY_FILE, "r") as f:
        API_KEY = f.read().strip()

if not API_KEY:
    print("נראה שזו פעם ראשונה שאתה מריץ את התוכנה.")
    print("תוכל להנפיק מפתח API חינמי באתר: https://aistudio.google.com/app/apikey")
    API_KEY = input("אנא הדבק את מפתח ה-API שלך כאן ולחץ אנטר: ").strip()
    with open(KEY_FILE, "w") as f:
        f.write(API_KEY)
    print("✅ המפתח נשמר בהצלחה לקריאות הבאות!\n")

client = genai.Client(api_key=API_KEY)

print("באיזה מצב תרצה להריץ את ההמרה?")
print("1. מצב מהיר (Fast Lite) - טוב לרוב הספרים, חוסך זמן.")
print("2. מצב איכותי (Strict Clean) - מודל כבד יותר, מתאים לטקסטים מורכבים במיוחד.")
choice = input("בחר 1 או 2 (ברירת מחדל 1): ").strip()

if choice == "2":
    MODE = "STRICT_CLEAN"
    MODEL_NAME = "gemini-3-flash" # בהתאם למודלים שביקשת
    log(f"\n--- נבחר מצב איכותי ({MODEL_NAME}) ---")
else:
    MODE = "FAST_LITE"
    MODEL_NAME = "gemini-3.1-flash-lite"
    log(f"\n--- נבחר מצב מהיר ({MODEL_NAME}) ---")

# המתנה למשתמש שישים קבצים
files = [f for f in os.listdir(INPUT_DIR) if f.lower().endswith((".pdf", ".epub"))]
if not files:
    print(f"\n⚠️ התיקייה {INPUT_DIR} ריקה!")
    print("אנא גרור לתוכה קבצי PDF או EPUB שברצונך להמיר.")
    input("לאחר שהכנסת קבצים לתיקייה, לחץ אנטר כדי להתחיל...")
    files = [f for f in os.listdir(INPUT_DIR) if f.lower().endswith((".pdf", ".epub"))]
    if not files:
        print("עדיין לא נמצאו קבצים. התוכנה נסגרת.")
        sys.exit()

# ==============================================================================
# פונקציות העבודה המקוריות (הותאמו במקצת)
# ==============================================================================

PREMIUM_PROMPT = """
אתה פועל בשני שלבים קשיחים:
שלב 1 (ניתוח ויזואלי): תאר לעצמך (במחשבה הפנימית שלך) את צורת האותיות המדויקת שאתה רואה בתמונה עבור המילים המומצאות, בלי לנסות לחבר אותן למילים אמיתיות בעברית.
שלב 2 (הפלט הסופי): פלוט אך ורק את התווים הפיזיים שזיהית בשלב 1
חוקים קריטיים נוספים:
1. שיבוץ תמונות וציורים: אל תשכח לשבץ כל תמונה , מפה או ציור שאתה רואה במקום המדויק שלו יחסית לטקסט בעמוד באמצעות תגית <img src="image_{page}_{index}.png" />.
2. דפים גרפיים מלאים: אם העמוד הוא מפה (MAP) או ציור שלם ללא טקסט סיפורי בכלל, פלוט אך ורק את התג הבא: <GRAPHIC_PAGE_DETECTED />
3. פורמט: פלוט טקסט נקי בתוך קוד HTML בעברית עם כיווניות מימין לשמאל: <div dir="rtl">. השתמש בתגיות <p> עבור פסקאות.
4. ללא קוד מרקדאון: אל תעטוף בסימני ```html או ```. פלוט את הטקסט ישירות.
"""

FAST_PROMPT = """
ACT AS A HIGH-PRECISION OCR ENGINE. 
YOUR TASK: Convert this image to HTML with 100% literal fidelity.
CRITICAL RULES:
1. EXACT TRANSCRIPTION: Transcribe exactly the characters you see. Do NOT substitute or guess based on Hebrew grammar. 
2. IMAGES & MAPS: If you see any map, drawing, or illustration, insert an <img src="image_{page}_{index}.png" /> tag exactly where it appears relative to the text.
3. FULL PAGE GRAPHICS: If the page is a MAP or ILLUSTRATION with no body text, output ONLY: <GRAPHIC_PAGE_DETECTED />
4. FORMATTING: Use Hebrew (RTL), wrap in <div dir="rtl">. Use <p> for paragraphs.
5. OUTPUT ONLY HTML. NO MARKDOWN CODE BLOCKS. NO INTRO/OUTRO.
"""

CURRENT_PROMPT = PREMIUM_PROMPT if MODE == "STRICT_CLEAN" else FAST_PROMPT

def clean_html(raw_html):
    if not raw_html or "<GRAPHIC_PAGE_DETECTED />" in raw_html: return "<GRAPHIC_PAGE_DETECTED />"
    return raw_html.replace("```html", "").replace("```", "").strip()

def boost_image_quality(img_path):
    try:
        with Image.open(img_path) as img:
            if img.width < 2000:
                new_size = (img.width * 2, img.height * 2)
                img = img.resize(new_size, Image.Resampling.LANCZOS)
                img.save(img_path, quality=95)
    except Exception as e: log(f"  [אזהרה] שיפור איכות נכשל: {e}")

def advance_opencv_clean(img_path):
    try:
        img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
        if img is None: return
        thresh = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]
        coords = np.column_stack(np.where(thresh > 0))
        if len(coords) == 0: return # תיקון הבאג של עמוד ריק
        
        angle = cv2.minAreaRect(coords)[-1]
        if angle < -45: angle = -(90 + angle)
        else: angle = -angle
        if 0.5 < abs(angle) < 15:
            (h, w) = img.shape[:2]
            center = (w // 2, h // 2)
            M = cv2.getRotationMatrix2D(center, angle, 1.0)
            img = cv2.warpAffine(img, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
        img = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 21, 15)
        cv2.imwrite(img_path, img)
    except Exception as e: log(f"  [אזהרה] ניקוי OpenCV נכשל: {e}")

def extract_images_from_epub(epub_path, cache_dir):
    book = epub.read_epub(epub_path)
    page_images = []
    images = [item for item in book.get_items() if item.get_type() == ITEM_IMAGE]
    def natural_sort_key(item):
        fname = item.file_name.split('/')[-1].lower()
        if 'cover' in fname: return (0, 0)
        numbers = [int(s) for s in re.findall(r'\d+', fname)]
        if numbers: return (1, numbers[0])
        return (2, fname)
    images.sort(key=natural_sort_key)
    for i, img_item in enumerate(images):
        img_ext = img_item.file_name.split('.')[-1]
        img_name = f"page_raw_{i:04d}.{img_ext}"
        path = os.path.join(cache_dir, img_name)
        with open(path, "wb") as f: f.write(img_item.content)
        page_images.append((i, path))
    return page_images

def build_final_epub(filename, cache_dir, total_pages):
    book = epub.EpubBook()
    book.set_identifier(str(uuid4()))
    book.set_title(filename.rsplit('.', 1)[0])
    book.set_language('he')
    style = 'body { direction: rtl; text-align: right; font-family: "Arial", sans-serif; line-height: 1.6; } img { max-width: 100%; height: auto; display: block; margin: 0 auto; }'
    spine = ['nav']
    for i in range(total_pages):
        html_path = os.path.join(cache_dir, f"page_{i}.html")
        if not os.path.exists(html_path): continue
        with open(html_path, "r", encoding="utf-8") as f: content = f.read()
        chapter = epub.EpubHtml(title=f'Page {i+1}', file_name=f'page_{i+1}.xhtml', lang='he')
        if "<GRAPHIC_PAGE_DETECTED />" in content:
            img_file = f"image_{i}_0.png"
            chapter.content = f'<html><head><style>{style}</style></head><body style="margin:0;"><img src="{img_file}" style="width:100%" /></body></html>'
        else:
            chapter.content = f'<html><head><style>{style}</style></head><body>{content}</body></html>'
        book.add_item(chapter)
        spine.append(chapter)
        for f in os.listdir(cache_dir):
            if f.startswith(f"image_{i}_") and f.endswith(".png"):
                with open(os.path.join(cache_dir, f), "rb") as img_f:
                    book.add_item(epub.EpubItem(uid=f.replace(".","_"), file_name=f, media_type="image/png", content=img_f.read()))
    book.spine = spine
    suffix = "_premium.epub" if MODE == "STRICT_CLEAN" else "_fast_lite.epub"
    out = filename.rsplit('.', 1)[0] + suffix
    epub.write_epub(os.path.join(OUTPUT_DIR, out), book)
    log(f"\n הושלמה המרת הספר: {out}")
    log(f" הקובץ ממתין לך בתיקיית: {OUTPUT_DIR}")

def process_file(filename):
    filepath = os.path.join(INPUT_DIR, filename)
    cache_tag = "premium" if MODE == "STRICT_CLEAN" else "fast_lite"
    cache_dir = os.path.join(OUTPUT_DIR, f".cache_{cache_tag}_{filename.replace('.', '_').replace(' ', '_')}")
    os.makedirs(cache_dir, exist_ok=True)
    pages = []
    
    log(f"\n>> מתחיל לעבד את הספר: {filename}...")
    
    if filename.lower().endswith(".pdf"):
        doc = fitz.open(filepath)
        for i in range(len(doc)):
            img_path = os.path.join(cache_dir, f"temp_p_{i}.png")
            if not os.path.exists(os.path.join(cache_dir, f"page_{i}.html")):
                pix = doc[i].get_pixmap(matrix=fitz.Matrix(4, 4))
                pix.save(img_path)
            for idx, img in enumerate(doc[i].get_images(full=True)):
                with open(os.path.join(cache_dir, f"image_{i}_{idx}.png"), "wb") as f: f.write(doc.extract_image(img[0])["image"])
            pages.append((i, img_path))
    elif filename.lower().endswith(".epub"):
        pages = extract_images_from_epub(filepath, cache_dir)
        for i, p in pages:
            with open(p, "rb") as f:
                with open(os.path.join(cache_dir, f"image_{i}_0.png"), "wb") as out: out.write(f.read())
    
    for i, img_path in pages:
        page_cache = os.path.join(cache_dir, f"page_{i}.html")
        
        if os.path.exists(page_cache):
            with open(page_cache, "r", encoding="utf-8") as f: existing_content = f.read().strip()
            if len(existing_content) > 20 or "<div dir='rtl'></div>" in existing_content or "image_" in existing_content:
                continue

        boost_image_quality(img_path)
        if MODE == "STRICT_CLEAN": advance_opencv_clean(img_path)
        
        max_retries = 3
        for attempt in range(max_retries):
            start_t = time.time()
            try:
                with open(img_path, "rb") as f:
                    image_bytes = f.read()
                
                image_part = types.Part.from_bytes(data=image_bytes, mime_type='image/png')
                
                # הזרקה בטוחה של האינדקס לפרומפט למניעת קריסות פירמוט
                formatted_prompt = CURRENT_PROMPT.replace("{page}", str(i)).replace("{index}", "0")
                
                resp = client.models.generate_content(
                    model=MODEL_NAME, 
                    contents=[image_part, formatted_prompt],
                    config={
                        'temperature': 1.0,
                        'max_output_tokens': 8192,
                    }
                )
                
                try: output_text = resp.text if resp.text else ""
                except Exception: output_text = ""
                
                if not output_text:
                    output_text = "<div dir='rtl'></div>"

                with open(page_cache, "w", encoding="utf-8") as f: f.write(clean_html(output_text))
                
                log(f"[{filename}] עמוד {i+1}/{len(pages)} פוענח בהצלחה ✅")
                time.sleep(max(0.1, 4.1 - (time.time() - start_t)))
                break
                
            except Exception as e:
                log(f"[{filename}] שגיאה בעמוד {i+1} (ניסיון {attempt+1}/{max_retries}): {e}")
                time.sleep(10)
        else:
            log(f"[{filename}] ❌ כישלון בעמוד {i+1}. משבץ תמונה במקום טקסט.")
            fallback_img_name = f"image_{i}_fallback.png"
            shutil.copy(img_path, os.path.join(cache_dir, fallback_img_name))
            with open(page_cache, "w", encoding="utf-8") as f: 
                f.write(f"<div dir='rtl'><img src='{fallback_img_name}' style='width:100%' /></div>")
            
    build_final_epub(filename, cache_dir, len(pages))

if __name__ == "__main__":
    MAX_WORKERS = 3
    
    log(f"\n מתחיל בעיבוד {len(files)} ספרים מתיקיית ה-input_books...")
    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
        executor.map(process_file, files)
        
    print("\n✅ כל הספרים עובדו בהצלחה! אפשר לסגור את החלון.")
    input("לחץ אנטר ליציאה...")

(זה ממיר ל EPUB אם אתה רוצה המרה לטקסט תבקש מ AI עזרה לשינוי הפרופמט או שתשנה בעצמך)