Update app.py

app.py

@@ -1,57 +1,171 @@
-from flask import Flask, request, Response, stream_with_context
-import requests
+import os
+import torch
+import gradio as gr
+import fitz
+from PIL import Image
+import logging
 
-app = Flask(__name__)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-HOST = "http://26.dragonpro.net:8080"
-USER = "kliU0JlomQ"
-PASS = "vXre5KnfxF"
-USER_AGENT = "IPTVSmarters/1.0.3 (iPad; iOS 13.4.1; Scale/2.00)"
+os.environ["TRANSFORMERS_NO_TORCHVISION"] = "1"
 
-session = requests.Session()
-session.headers.update({'User-Agent': USER_AGENT})
+_model = None
+_tokenizer = None
+_img_proc = None
+_model_loaded = False
 
-@app.route('/')
-def status():
-    return "XTREAM_GATEWAY_V2_LOCKED"
+def load_model():
+    global _model, _tokenizer, _img_proc, _model_loaded
+    
+    if _model_loaded:
+        return
+    
+    try:
+        from transformers import Qwen2VLForConditionalGeneration, AutoTokenizer, Qwen2VLImageProcessor
+        from peft import PeftModel
+        
+        logger.info("Loading base model...")
+        _tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-VL-2B-Instruct", trust_remote_code=True)
+        _img_proc = Qwen2VLImageProcessor.from_pretrained("Qwen/Qwen2-VL-2B-Instruct", trust_remote_code=True)
+        
+        base = Qwen2VLForConditionalGeneration.from_pretrained(
+            "Qwen/Qwen2-VL-2B-Instruct",
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto" if torch.cuda.is_available() else "cpu"
+        )
+        
+        logger.info("Loading LoRA adapter...")
+        peft_model = PeftModel.from_pretrained(base, "NaserNajeh/Horoof")
+        _model = peft_model.merge_and_unload()
+        _model.eval()
+        _model_loaded = True
+        logger.info("✅ Model loaded!")
+        
+    except Exception as e:
+        logger.error(f"Error loading model: {e}")
+        raise
 
-@app.route('/<path:path>')
-def ghost_proxy(path):
-    query_params = dict(request.args)
+def pdf_to_images(pdf_bytes, dpi=220, max_pages=2):
+    pages_imgs = []
+    doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+    
+    n_pages = min(max_pages, doc.page_count)
+    
+    for i in range(n_pages):
+        try:
+            page = doc.load_page(i)
+            mat = fitz.Matrix(dpi/72, dpi/72)
+            pix = page.get_pixmap(matrix=mat, alpha=False)
+            
+            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+            
+            if max(img.size) > 2048:
+                img.thumbnail((2048, 2048), Image.Resampling.LANCZOS)
+            
+            pages_imgs.append((i + 1, img))
+            logger.info(f"✅ Converted page {i+1}")
+            
+        except Exception as e:
+            logger.error(f"Error on page {i+1}: {e}")
+            continue
     
-    # Credentials are NEVER exposed to the player or the browser. 
-    # They are injected here, inside the server.
-    if any(x in path for x in ["player_api.php", "xmltv.php", "get.php"]):
-        query_params['username'] = USER
-        query_params['password'] = PASS
+    doc.close()
+    return pages_imgs
 
-    target_url = f"{HOST}/{path}"
-    headers = {k: v for k, v in request.headers if k.lower() not in ['host', 'user-agent']}
+def ocr_page(pil_img, max_tokens=1200):
+    try:
+        load_model()
+        
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": pil_img},
+                    {"type": "text", "text": "اقرأ النص العربي في الصورة كما هو دون أي تعديل."},
+                ],
+            }
+        ]
+
+        tok = _tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_tensors="pt")
+        vis = _img_proc(images=[pil_img], return_tensors="pt")
+
+        inputs = {"input_ids": tok}
+        inputs.update(vis)
+        
+        if torch.cuda.is_available():
+            for k, v in inputs.items():
+                if hasattr(v, "to"):
+                    inputs[k] = v.to("cuda")
+
+        with torch.inference_mode():
+            output_ids = _model.generate(**inputs, max_new_tokens=max_tokens, do_sample=False)
+        
+        generated_part = output_ids[0][len(inputs["input_ids"][0]):]
+        result = _tokenizer.decode(generated_part, skip_special_tokens=True).strip()
+        
+        return result if result else "No text extracted"
+        
+    except Exception as e:
+        logger.error(f"OCR Error: {e}")
+        return f"Error: {e}"
+
+def process_pdf(pdf_file, dpi, pages):
+    if pdf_file is None:
+        return "❌ No PDF uploaded"
     
     try:
-        r = session.get(target_url, params=query_params, headers=headers, stream=True, timeout=15)
-        
-        excluded_headers = ['content-encoding', 'content-length', 'transfer-encoding', 'connection']
-        resp_headers = [(name, value) for (name, value) in r.raw.headers.items()
-                        if name.lower() not in excluded_headers]
-
-        def stream_logic():
-            try:
-                # 128KB chunks for the fastest possible zapping/opening in Cairo.
-                for chunk in r.iter_content(chunk_size=131072):
-                    if chunk:
-                        yield chunk
-            except:
-                pass
-            finally:
-                r.close()
-
-        return Response(stream_with_context(stream_logic()), 
-                        status=r.status_code, 
-                        content_type=r.headers.get('Content-Type', 'video/mp2t'),
-                        headers=resp_headers)
-    except:
-        return "Gateway Timeout", 504
-
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860, threaded=True)
+        logger.info("🔄 Processing PDF...")
+        
+        if hasattr(pdf_file, 'read'):
+            pdf_bytes = pdf_file.read()
+        else:
+            pdf_bytes = pdf_file
+        
+        if not pdf_bytes:
+            return "❌ Empty file"
+        
+        dpi_val = max(150, min(300, int(dpi)))
+        pages_limit = max(1, int(pages))
+        
+        logger.info(f"Converting {pages_limit} pages at {dpi_val} DPI...")
+        pages_imgs = pdf_to_images(pdf_bytes, dpi=dpi_val, max_pages=pages_limit)
+        
+        if not pages_imgs:
+            return "❌ No valid pages"
+        
+        results = []
+        for page_num, img in pages_imgs:
+            logger.info(f"Processing page {page_num}...")
+            text = ocr_page(img)
+            results.append(f"📄 **Page {page_num}**\n{'='*60}\n{text}")
+        
+        return "\n\n".join(results)
+        
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        return f"❌ Error: {e}"
+
+# Gradio Interface
+with gr.Blocks(title="Horoof OCR") as demo:
+    gr.Markdown("""
+    # 🔤 Horoof OCR - Arabic Text Extraction
+    
+    **Model**: Qwen2-VL-2B + Horoof LoRA  
+    **For**: Quran & Arabic Text with Diacritics
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            pdf_input = gr.File(label="📁 Upload PDF", file_types=[".pdf"], type="binary")
+            dpi_slider = gr.Slider(150, 300, 220, step=10, label="🎯 DPI")
+            pages_slider = gr.Slider(1, 10, 2, step=1, label="📊 Pages")
+            btn = gr.Button("🚀 Extract Text", variant="primary", size="lg")
+        
+        with gr.Column(scale=2):
+            output = gr.Textbox(label="📝 Extracted Text", lines=20, show_copy_button=True)
+    
+    btn.click(fn=process_pdf, inputs=[pdf_input, dpi_slider, pages_slider], outputs=output)
+
+demo.queue()
+demo.launch()