Prepare project for Hugging Face Spaces with Gradio and bundled models

.dockerignore

@@ -1,9 +0,0 @@
-__pycache__/
-*.pyc
-*.pyo
-*.pyd
-.Python
-env/
-venv/
-.git/
-*.egg-info/

.gitignore

@@ -1,8 +1,36 @@
+# Python
 __pycache__/
-*.pyc
-*.pyo
-*.pyd
-uploads/
+*.py[cod]
+*$py.class
+*.egg-info/
 .env
+.venv
+env/
 venv/
+ENV/
+env.bak/
+venv.bak/
+
+# PaddleOCR / PaddlePaddle cache (if any created locally, not strictly needed for repo)
+.paddlehub/
+.paddleocr/
+
+# IDE / OS files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
 .DS_Store
+Thumbs.db
+
+# Local model downloads if you accidentally commit them outside the designated 'paddleocr_models' dir
+# (The 'paddleocr_models' directory itself SHOULD be committed)
+
+# If you use Git LFS for models (optional, if models are very large)
+# .gitattributes # This file itself should be committed if LFS is used
+# *.pdparams # Example if you track these with LFS
+
+# Output files
+result.jpg
+result.png

Dockerfile

@@ -1,28 +0,0 @@
-# Use official Python image
-FROM python:3.9-slim
-
-# Set working directory
-WORKDIR /app
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    libgl1-mesa-glx \
-    libgomp1 \
-    libglib2.0-0 \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install Python dependencies
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy app files
-COPY . .
-
-# Set environment variable for port
-ENV PORT=8080
-
-# Expose the port
-EXPOSE 8080
-
-# Start the app
-CMD ["gunicorn", "--bind", "0.0.0.0:8080", "app:app"]

app.py

@@ -1,72 +1,191 @@
-from flask import Flask, render_template, request, redirect, flash, url_for
-import os
-from werkzeug.utils import secure_filename
-from paddleocr import PaddleOCR
+import gradio as gr
+from paddleocr import PaddleOCR, draw_ocr
 from PIL import Image
-import gc
-
-app = Flask(__name__)
-app.secret_key = os.environ.get('SECRET_KEY', 'change-this')  # Replace in production
-UPLOAD_FOLDER = os.path.join('static', 'uploads')
-app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-
-# Ensure upload directory exists
-os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-
-# Initialize PaddleOCR once at the start (use CPU mode)
-ocr = PaddleOCR(
-    use_angle_cls=False,
-    use_gpu=False,
-    lang='en',
-    det_model_dir='/tmp/ocr_models/det',
-    rec_model_dir='/tmp/ocr_models/rec',
-    cls_model_dir='/tmp/ocr_models/cls'
-)
+import numpy as np
+import os
+
+# --- Configuration: Model and Font Paths ---
+# IMPORTANT: Ensure these paths and folder names match exactly what you have
+# in your 'paddleocr_models' directory.
+
+# Define the language
+SELECTED_LANGUAGE = 'en' # This informs which dictionary to look for primarily
+
+# Base directory for your bundled models
+MODEL_BASE_DIR = 'paddleocr_models'
+
+# --- Model paths based on your logs ---
+# Detection model: en_PP-OCRv3_det_infer
+DET_MODEL_FOLDER_NAME = 'en_PP-OCRv3_det_infer'
+DET_MODEL_DIR_DEFAULT = os.path.join(MODEL_BASE_DIR, DET_MODEL_FOLDER_NAME)
+
+# Recognition model: en_PP-OCRv4_rec_infer
+REC_MODEL_FOLDER_NAME = 'en_PP-OCRv4_rec_infer'
+REC_MODEL_DIR_DEFAULT = os.path.join(MODEL_BASE_DIR, REC_MODEL_FOLDER_NAME)
+
+# Classification model: ch_ppocr_mobile_v2.0_cls_infer (often shared)
+CLS_MODEL_FOLDER_NAME = 'ch_ppocr_mobile_v2.0_cls_infer'
+CLS_MODEL_DIR_DEFAULT = os.path.join(MODEL_BASE_DIR, CLS_MODEL_FOLDER_NAME)
+
+# --- Character Dictionary Path ---
+# Since en_dict.txt might not be directly in the rec_model_dir after copying from cache,
+# we assume you've copied the default en_dict.txt into your REC_MODEL_FOLDER_NAME.
+# If you copied it from the PaddleOCR package utils, this path should be correct.
+# Ensure 'en_dict.txt' is inside 'paddleocr_models/en_PP-OCRv4_rec_infer/'
+REC_CHAR_DICT_FILENAME = 'en_dict.txt' # Or whatever your .txt file is named
+REC_CHAR_DICT_PATH_DEFAULT = os.path.join(REC_MODEL_DIR_DEFAULT, REC_CHAR_DICT_FILENAME)
+
+# --- Font for drawing OCR results ---
+FONT_PATH = 'latin.ttf' # Ensure 'latin.ttf' (e.g., DejaVuSans.ttf renamed) is in your project root.
+if not os.path.exists(FONT_PATH):
+    print(f"WARNING: Font file '{FONT_PATH}' not found. Text rendering on images might fail or look incorrect.")
+
+# --- Initialize PaddleOCR Engine ---
+ocr_engine = None
+try:
+    # Check if essential model directories exist
+    if not os.path.exists(DET_MODEL_DIR_DEFAULT):
+        raise FileNotFoundError(f"Detection model directory not found: '{DET_MODEL_DIR_DEFAULT}'. Please ensure it exists and contains model files.")
+    if not os.path.exists(REC_MODEL_DIR_DEFAULT):
+        raise FileNotFoundError(f"Recognition model directory not found: '{REC_MODEL_DIR_DEFAULT}'. Please ensure it exists and contains model files.")
+    
+    # Check if the character dictionary file exists
+    if not os.path.exists(REC_CHAR_DICT_PATH_DEFAULT):
+        raise FileNotFoundError(f"Recognition character dictionary not found: '{REC_CHAR_DICT_PATH_DEFAULT}'. Please ensure it's in the recognition model folder.")
+
+    print(f"Initializing PaddleOCR with language: {SELECTED_LANGUAGE}")
+    print(f"  Detection Model Dir: {DET_MODEL_DIR_DEFAULT}")
+    print(f"  Recognition Model Dir: {REC_MODEL_DIR_DEFAULT}")
+    print(f"  Recognition Char Dict Path: {REC_CHAR_DICT_PATH_DEFAULT}")
+    
+    use_cls = os.path.exists(CLS_MODEL_DIR_DEFAULT)
+    if use_cls:
+        print(f"  Classification Model Dir: {CLS_MODEL_DIR_DEFAULT}")
+    else:
+        print(f"  Classification Model: Not found at '{CLS_MODEL_DIR_DEFAULT}' or not used.")
+
+    ocr_engine = PaddleOCR(
+        use_angle_cls=use_cls,
+        lang=SELECTED_LANGUAGE, # Still useful for some internal logic, but dict path is key
+        det_model_dir=DET_MODEL_DIR_DEFAULT,
+        rec_model_dir=REC_MODEL_DIR_DEFAULT,
+        rec_char_dict_path=REC_CHAR_DICT_PATH_DEFAULT, # Explicitly providing the dictionary path
+        cls_model_dir=CLS_MODEL_DIR_DEFAULT if use_cls else None,
+        show_log=True, # Set to False for less verbose logs in production if desired
+        use_gpu=False # Set to True if you have GPU hardware on Spaces and paddlepaddle-gpu
+    )
+    print("PaddleOCR engine initialized successfully from local models.")
 
-# Resize image before processing to reduce memory usage
-def resize_image(image_path):
-    with Image.open(image_path) as img:
-        img.thumbnail((1024, 1024))  # Resize to max dimension of 1024x1024
-        img.save(image_path)
-
-@app.route('/', methods=['GET', 'POST'])
-def index():
-    extracted_text = None
-    image_file = None
-
-    if request.method == 'POST':
-        # Check file in request
-        if 'image' not in request.files:
-            flash('No file part in the request.')
-            return redirect(request.url)
-        file = request.files['image']
-        if file.filename == '':
-            flash('No image selected.')
-            return redirect(request.url)
-
-        # Save uploaded file
-        filename = secure_filename(file.filename)
-        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-        file.save(file_path)
-
-        # Resize the image to optimize memory usage
-        resize_image(file_path)
-
-        # Run PaddleOCR on the resized image (CPU mode)
-        result = ocr.ocr(file_path, cls=False)
-        # Collect recognized text lines
-        lines = []
-        for res_line in result:
-            for box, (txt, prob) in res_line:
-                lines.append(txt)
-        extracted_text = "\n".join(lines)
-        image_file = filename
-
-        # Clear memory after processing
-        del result
-        gc.collect()
-
-    return render_template('index.html', extracted_text=extracted_text, image_file=image_file)
+except FileNotFoundError as fnf_error:
+    print(f"FATAL ERROR (FileNotFound): {fnf_error}")
+    print("Please check your 'paddleocr_models' directory and model/dict file paths in app.py.")
+    ocr_engine = None
+except Exception as e:
+    print(f"FATAL ERROR: Could not initialize PaddleOCR engine: {e}")
+    ocr_engine = None # Ensure it's None if initialization fails
+
+def ocr_process(image_pil, language_key_display_name):
+    """
+    Processes the uploaded image with PaddleOCR using the pre-loaded models.
+    """
+    if ocr_engine is None:
+        # This message will be displayed to the user in the Gradio interface
+        return None, "PaddleOCR engine is not available. Please check the application logs for errors."
+    if image_pil is None:
+        return None, "No image provided. Please upload an image."
+
+    print(f"Processing with pre-loaded language: {SELECTED_LANGUAGE}")
+
+    try:
+        img_np = np.array(image_pil.convert('RGB')) # Ensure image is RGB
+
+        print("Performing OCR...")
+        # The `ocr` method automatically uses the det, cls (if enabled), and rec models.
+        result = ocr_engine.ocr(img_np, cls=ocr_engine.use_angle_cls) 
+        print("OCR processing complete.")
+
+        # PaddleOCR v2.6+ returns results in a different structure: result = [[box, (text, score)], ...]
+        # Check if result is not None and the first element (lines) is not empty
+        if result is None or not result[0]: 
+            print("No text detected.")
+            return image_pil, "No text detected." 
+
+        # Correctly extract boxes, texts, and scores from the result structure
+        # result[0] contains the list of lines, where each line is [box, (text, score)]
+        lines = result[0]
+        boxes = [line[0] for line in lines]
+        txts = [line[1][0] for line in lines]
+        scores = [line[1][1] for line in lines]
+
+        print("Drawing OCR results...")
+        if not os.path.exists(FONT_PATH):
+            print(f"Font file '{FONT_PATH}' still not found. Cannot draw results on image.")
+            # Return original image and extracted text without drawn boxes
+            extracted_text_raw = "\n".join(txts)
+            return image_pil, f"Font file missing. Extracted text (raw):\n{extracted_text_raw}"
+
+        # draw_ocr expects the image in a format it can handle (PIL Image is fine)
+        im_show = draw_ocr(image_pil, boxes, txts, scores, font_path=FONT_PATH)
+        im_show_pil = Image.fromarray(im_show) # Convert numpy array from draw_ocr back to PIL Image
+        print("OCR results drawn.")
+
+        extracted_text = "\n".join(txts)
+        return im_show_pil, extracted_text
+
+    except Exception as e:
+        print(f"Error during OCR processing: {e}")
+        # Return original image and error message
+        return image_pil, f"An error occurred during OCR: {str(e)}"
+
+# --- Gradio Interface Definition ---
+title = "PaddleOCR Web App (Bundled Models)"
+description = f"""
+Upload an image to perform OCR. This app uses PaddleOCR with pre-bundled models
+for the **{SELECTED_LANGUAGE.upper()}** language to avoid re-downloads on Hugging Face Spaces.
+Detection: `{DET_MODEL_FOLDER_NAME}`
+Recognition: `{REC_MODEL_FOLDER_NAME}` (using `{REC_CHAR_DICT_FILENAME}`)
+Make sure the model files are correctly placed in the `paddleocr_models` directory
+and the font file `{FONT_PATH}` is in the project root.
+"""
+article = "<p style='text-align: center'>Powered by PaddleOCR and Gradio. Deployed on Hugging Face Spaces.</p>"
+
+# For this setup, the language dropdown is mainly informational as models are pre-loaded.
+# To truly switch languages, ocr_engine would need re-initialization with different model/dict paths.
+supported_langs_display_for_dropdown = {
+    "English (Loaded)": "en",
+    # "Chinese (Not Loaded)": "ch", # Example if you were to add more
+}
+
+iface = gr.Interface(
+    fn=ocr_process,
+    inputs=[
+        gr.Image(type="pil", label="Upload Image"),
+        gr.Dropdown(
+            choices=list(supported_langs_display_for_dropdown.keys()),
+            label="Language (Using Pre-loaded Model)",
+            # Default to the key corresponding to SELECTED_LANGUAGE
+            value=[k for k, v in supported_langs_display_for_dropdown.items() if v == SELECTED_LANGUAGE][0]
+        )
+    ],
+    outputs=[
+        gr.Image(type="pil", label="Processed Image with OCR"),
+        gr.Textbox(label="Extracted Text", lines=10, show_copy_button=True)
+    ],
+    title=title,
+    description=description,
+    article=article,
+    allow_flagging='never', # Disables the "Flag" button
+    # You can add example images to your repository and list them here
+    # examples=[
+    #     ["path_to_your_example_image_in_repo.png", "English (Loaded)"] 
+    # ]
+)
 
 if __name__ == '__main__':
-    app.run(debug=True)
+    if ocr_engine is None:
+        print("OCR Engine could not be initialized. The Gradio app will not function correctly.")
+        # In a real scenario, you might want to display an error in the Gradio UI itself
+        # by modifying the interface or raising an error that Gradio can catch.
+    print("Launching Gradio interface...")
+    iface.launch() 
+    print("Gradio interface launched.")

download_ocr_models.py

@@ -0,0 +1,129 @@
+# download_ocr_models.py (Corrected v3)
+from paddleocr import PaddleOCR
+import os
+import shutil # For copying files/folders later if you want to automate it
+
+# --- CONFIGURATION ---
+# 1. CHOOSE THE LANGUAGE YOU WANT TO DOWNLOAD MODELS FOR:
+LANGUAGE_TO_DOWNLOAD = 'en'  # <<< ***** CHANGE THIS TO YOUR TARGET LANGUAGE *****
+# --- END CONFIGURATION ---
+
+print(f"Attempting to download/locate models for language: '{LANGUAGE_TO_DOWNLOAD}'...")
+
+try:
+    # Initialize PaddleOCR. This action will trigger the download of models
+    # for the specified language if they are not already in the local cache.
+    ocr_temp_engine = PaddleOCR(use_angle_cls=True, lang=LANGUAGE_TO_DOWNLOAD, show_log=True)
+    print(f"\nModels for '{LANGUAGE_TO_DOWNLOAD}' should now be in the PaddleOCR cache.")
+
+    # --- Accessing the model paths from the initialized engine ---
+    # The args object is an argparse.Namespace, access attributes directly.
+    
+    args = ocr_temp_engine.args # This is an argparse.Namespace object
+
+    # Use hasattr to check if attributes exist before accessing them
+    det_model_dir_cache = args.det_model_dir if hasattr(args, 'det_model_dir') else None
+    rec_model_dir_cache = args.rec_model_dir if hasattr(args, 'rec_model_dir') else None
+    cls_model_dir_cache = args.cls_model_dir if hasattr(args, 'use_angle_cls') and args.use_angle_cls and hasattr(args, 'cls_model_dir') else None
+    rec_char_dict_path_from_args = args.rec_char_dict_path if hasattr(args, 'rec_char_dict_path') else None
+
+
+    print("\n--- CACHE PATHS FOR THE DOWNLOADED MODELS (from PaddleOCR config) ---")
+    if det_model_dir_cache:
+        print(f"Detection ({LANGUAGE_TO_DOWNLOAD}) model cache path: {det_model_dir_cache}")
+    else:
+        print(f"Detection ({LANGUAGE_TO_DOWNLOAD}) model cache path: Not found in args (Attribute 'det_model_dir' missing).")
+    
+    if rec_model_dir_cache:
+        print(f"Recognition ({LANGUAGE_TO_DOWNLOAD}) model cache path: {rec_model_dir_cache}")
+    else:
+        print(f"Recognition ({LANGUAGE_TO_DOWNLOAD}) model cache path: Not found in args (Attribute 'rec_model_dir' missing).")
+
+    if cls_model_dir_cache:
+        print(f"Classification model cache path: {cls_model_dir_cache}")
+    elif hasattr(args, 'use_angle_cls') and args.use_angle_cls:
+        print("Classification model enabled but path not found in args (Attribute 'cls_model_dir' missing or invalid).")
+    else:
+        print("Classification model not used or path not found in args.")
+
+
+    # --- Instructions for copying ---
+    print("\n--- ACTION REQUIRED ---")
+    print("1. Create a folder named 'paddleocr_models' in your project's root directory (if it doesn't exist).")
+    
+    project_root = os.getcwd() 
+    project_model_dir_target = os.path.join(project_root, 'paddleocr_models')
+    if not os.path.exists(project_model_dir_target):
+        try:
+            os.makedirs(project_model_dir_target)
+            print(f"   Created directory: {project_model_dir_target}")
+        except OSError as e:
+            print(f"   ERROR creating directory {project_model_dir_target}: {e}")
+            print("   Please create it manually.")
+    else:
+        print(f"   Your project's 'paddleocr_models' folder is at: {project_model_dir_target}")
+
+
+    print(f"\n2. Manually copy the following folders from the cache paths printed above (or from PaddleOCR's initial debug log) into '{project_model_dir_target}':")
+
+    # Detection model
+    if det_model_dir_cache and os.path.exists(det_model_dir_cache):
+        det_target_name = os.path.basename(os.path.normpath(det_model_dir_cache))
+        print(f"   - Detection Model Folder to Copy: '{det_target_name}'")
+        print(f"     (Full path of source: {det_model_dir_cache})")
+        print(f"     (Target location: {os.path.join(project_model_dir_target, det_target_name)})")
+    else:
+        print(f"   - Detection model directory NOT FOUND or path is invalid based on script access: {det_model_dir_cache}")
+        print(f"     IMPORTANT: Please check the initial PaddleOCR debug logs (the long block of text when PaddleOCR starts).")
+        print(f"     Look for the line starting with 'det_model_dir=' and use THAT PATH to find the folder to copy manually.")
+
+
+    # Recognition model
+    if rec_model_dir_cache and os.path.exists(rec_model_dir_cache):
+        rec_target_name = os.path.basename(os.path.normpath(rec_model_dir_cache))
+        print(f"   - Recognition Model Folder to Copy: '{rec_target_name}'")
+        print(f"     (Full path of source: {rec_model_dir_cache})")
+        print(f"     (Target location: {os.path.join(project_model_dir_target, rec_target_name)})")
+        
+        if rec_char_dict_path_from_args and os.path.exists(rec_char_dict_path_from_args):
+             print(f"     (Dictionary file used by PaddleOCR: '{os.path.basename(rec_char_dict_path_from_args)}' found at {rec_char_dict_path_from_args})")
+             print(f"     (Ensure a similar .txt dictionary file, like '{os.path.basename(rec_char_dict_path_from_args)}', is inside the '{rec_target_name}' folder you copy)")
+        else: 
+            found_dicts = [f for f in os.listdir(rec_model_dir_cache) if f.endswith('.txt')]
+            if found_dicts:
+                print(f"     (Ensure dictionary file like '{found_dicts[0]}' is inside the '{rec_target_name}' folder you copy)")
+            else:
+                print(f"     WARNING: Dictionary file (e.g., '{LANGUAGE_TO_DOWNLOAD}_dict.txt') NOT FOUND in {rec_model_dir_cache}")
+    else:
+        print(f"   - Recognition model directory NOT FOUND or path is invalid based on script access: {rec_model_dir_cache}")
+        print(f"     IMPORTANT: Please check the initial PaddleOCR debug logs.")
+        print(f"     Look for the line starting with 'rec_model_dir=' and use THAT PATH to find the folder to copy manually.")
+
+
+    # Classification model (optional)
+    if cls_model_dir_cache and os.path.exists(cls_model_dir_cache):
+        cls_target_name = os.path.basename(os.path.normpath(cls_model_dir_cache))
+        print(f"   - Classification Model Folder to Copy (Optional): '{cls_target_name}'")
+        print(f"     (Full path of source: {cls_model_dir_cache})")
+        print(f"     (Target location: {os.path.join(project_model_dir_target, cls_target_name)})")
+
+    elif hasattr(args, 'use_angle_cls') and args.use_angle_cls:
+        print(f"   - Classification model directory NOT FOUND or path is invalid based on script access: {cls_model_dir_cache}")
+        print(f"     IMPORTANT: Please check the initial PaddleOCR debug logs.")
+        print(f"     Look for the line starting with 'cls_model_dir=' and use THAT PATH to find the folder to copy manually if needed.")
+
+
+    print("\n3. After copying, your 'paddleocr_models' directory in your project should contain these model subfolders.")
+    print("4. Verify paths in your main `app.py` match these folder names.")
+    print("   For example, if your log showed 'en_PP-OCRv3_det_infer' for detection, app.py should use that name.")
+
+except AttributeError as ae:
+    print(f"An AttributeError occurred during script execution (not PaddleOCR init): {ae}")
+    print("This might indicate an unexpected structure in the PaddleOCR object or its arguments when accessed by the script.")
+    print("Please carefully review the FULL initial debug output from PaddleOCR when it initializes.")
+    print("The lines starting with 'det_model_dir=', 'rec_model_dir=', 'cls_model_dir=' are key.")
+    print("You can use those paths directly to find and copy the model folders manually.")
+except Exception as e:
+    print(f"An unexpected error occurred: {e}")
+    print("Please ensure PaddleOCR and PaddlePaddle are installed correctly.")
+

latin.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7da195a74c55bef988d0d48f9508bd5d849425c1770dba5d7bfc6ce9ed848954
+size 757076

paddleocr_models/ch_ppocr_mobile_v2.0_cls_infer/inference.pdiparams

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1efda1b80e174b4fcb168a035ac96c1af4938892bd86a55f300a6027105d08c
+size 539978

paddleocr_models/ch_ppocr_mobile_v2.0_cls_infer/inference.pdiparams.info

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee0c2eaa4c09814802bf520c01dfdbc1345dc2879dc9e67424d32c7b0ee88e59
+size 18545

paddleocr_models/ch_ppocr_mobile_v2.0_cls_infer/inference.pdmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c4337ec61722a20b1dca2e5bfaffc313c0592bc89ad6e0d45168224186f6683
+size 1624487

paddleocr_models/en_PP-OCRv3_det_infer/inference.pdiparams

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83676ec730627ab4502f401410a4b6a3ce1c0bb98fa249b71db055b6bddae051
+size 2377917

paddleocr_models/en_PP-OCRv3_det_infer/inference.pdiparams.info

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2fe414d9eadf914bf44e3f9ba212988a6f26f364e4f87c6d0af57438ffffc0c4
+size 26392

paddleocr_models/en_PP-OCRv3_det_infer/inference.pdmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4bfb1b05d9d1d5a760801eaf6d20180ef7e47bcc675fb17d1f3a89da5fef427
+size 1590133

paddleocr_models/en_PP-OCRv4_rec_infer/en_dict.txt

@@ -0,0 +1,95 @@
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+:
+;
+<
+=
+>
+?
+@
+A
+B
+C
+D
+E
+F
+G
+H
+I
+J
+K
+L
+M
+N
+O
+P
+Q
+R
+S
+T
+U
+V
+W
+X
+Y
+Z
+[
+\
+]
+^
+_
+`
+a
+b
+c
+d
+e
+f
+g
+h
+i
+j
+k
+l
+m
+n
+o
+p
+q
+r
+s
+t
+u
+v
+w
+x
+y
+z
+{
+|
+}
+~
+!
+"
+#
+$
+%
+&
+'
+(
+)
+*
++
+,
+-
+.
+/
+ 

paddleocr_models/en_PP-OCRv4_rec_infer/inference.pdiparams

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75f64a1ffb70c56b7a25655963ca16f5bf3286202e3f52ac972bee05cdee2f56
+size 7607269

paddleocr_models/en_PP-OCRv4_rec_infer/inference.pdiparams.info

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:710d9f3d7c503067ae708f4bc3adc6973c0d6391adb7a1470c36eb70da6b5b83
+size 102540

paddleocr_models/en_PP-OCRv4_rec_infer/inference.pdmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85b952f05f709af259cfe4254012aa7208bef0998f71f57a15495446f25ccd43
+size 2517366

render.yaml

@@ -1,10 +0,0 @@
-services:
-  - type: web
-    name: ocr-app
-    env: python
-    plan: free
-    buildCommand: pip install -r requirements.txt
-    startCommand: python app.py
-    envVars:
-      - key: PORT
-        value: 5000

requirements.txt

@@ -1,5 +1,15 @@
-Flask>=2.0.0
-gunicorn>=20.1.0
-paddleocr>=2.0.1
-paddlepaddle>=2.0.0
+# Core OCR and ML Framework
+paddleocr>=2.7.0    # Or your preferred version
+paddlepaddle>=2.6.0  # Or your preferred version, ensure compatibility with paddleocr
+
+# Image Processing
 opencv-python-headless>=4.8.0
+Pillow>=9.0.0
+
+# Web Application Interface
+gradio>=4.0.0       # Using Gradio instead of Flask/Gunicorn for Hugging Face Spaces
+
+# Utilities
+numpy>=1.20.0
+
+# Add any other specific utility libraries you might need

run_ocr.py

@@ -1,8 +0,0 @@
-from paddleocr import PaddleOCR
-
-ocr = PaddleOCR(use_angle_cls=True, lang='en', use_gpu=False)
-img_path = r"C:\Users\KRUNAL\OneDrive\Pictures\Camera imports\2024-08-22 (2)\1000015730.jpg"
-result = ocr.ocr(img_path, cls=True)
-
-print(result)
-

static/style.css

@@ -1,179 +0,0 @@
-/* body {
-    font-family: 'Poppins', sans-serif;
-    background: linear-gradient(135deg, #74ebd5, #ACB6E5);
-    margin: 0;
-    padding: 0;
-    min-height: 100vh;
-    display: flex;
-    justify-content: center;
-    align-items: center;
-}
-
-.container {
-    background: #ffffff;
-    padding: 40px;
-    border-radius: 20px;
-    box-shadow: 0 10px 40px rgba(0,0,0,0.2);
-    max-width: 700px;
-    width: 90%;
-    animation: fadeIn 1s ease-in;
-}
-
-h1 {
-    margin-bottom: 20px;
-    color: #333;
-    font-weight: 600;
-}
-
-.upload-form {
-    display: flex;
-    flex-direction: column;
-    gap: 20px;
-    margin-bottom: 30px;
-}
-
-input[type="file"] {
-    padding: 10px;
-    background: #f5f5f5;
-    border: 2px dashed #ccc;
-    border-radius: 10px;
-}
-
-button {
-    padding: 12px;
-    background: #007bff;
-    color: white;
-    border: none;
-    border-radius: 10px;
-    font-size: 16px;
-    cursor: pointer;
-    transition: background 0.3s;
-}
-
-button:hover {
-    background: #0056b3;
-}
-
-.preview img {
-    max-width: 100%;
-    max-height: 400px;
-    border-radius: 10px;
-    margin-top: 20px;
-}
-
-.output {
-    margin-top: 30px;
-    background: #f9f9f9;
-    padding: 20px;
-    border-radius: 10px;
-    word-break: break-word;
-}
-
-.error {
-    margin-top: 20px;
-    color: red;
-    font-weight: bold;
-}
-
-@keyframes fadeIn {
-    from { opacity: 0; transform: translateY(30px);}
-    to { opacity: 1; transform: translateY(0);}
-}
-
-#result-img {
-  max-width: 100%;
-  height: auto;
-  margin-top: 10px;
-  border: 1px solid #ddd;
-  border-radius: 8px;
-  padding: 4px;
-}
-#extracted-text {
-  text-align: left;
-  background: #fff;
-  padding: 15px;
-  border-radius: 8px;
-  border: 1px solid #ddd;
-}
-#spinner {
-   
-  position: fixed;
-  top: 50%;
-  left: 50%;
-  transform: translate(-50%, -50%);
-  z-index: 1000;
-} */
-/* static/style.css */
-/* static/style.css */
-body {
-    background: #f0f2f5;
-    font-family: 'Segoe UI', Tahoma, sans-serif;
-    color: #333;
-    margin: 0;
-    padding: 0;
-  }
-  .container {
-    max-width: 600px;
-    margin: 40px auto;
-    background: #fff;
-    border-radius: 8px;
-    padding: 20px;
-    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
-  }
-  h1, h2 {
-    color: #444;
-    margin-bottom: 10px;
-  }
-  p {
-    color: #666;
-  }
-  form {
-    margin-top: 20px;
-    display: flex;
-    gap: 10px;
-  }
-  input[type="file"] {
-    flex: 1;
-    padding: 8px;
-    border: 1px solid #ccc;
-    border-radius: 4px;
-  }
-  button {
-    background-color: #007BFF;
-    color: white;
-    border: none;
-    padding: 8px 16px;
-    border-radius: 4px;
-    cursor: pointer;
-  }
-  button:hover {
-    background-color: #0056b3;
-  }
-  .result, .image-preview {
-    margin-top: 20px;
-    padding: 10px;
-    border-top: 1px solid #e1e1e1;
-  }
-  .result pre {
-    background: #f8f9fa;
-    padding: 10px;
-    border-radius: 4px;
-    white-space: pre-wrap;
-  }
-  .flashes {
-    list-style: none;
-    padding: 10px;
-    background: #ffe0e0;
-    border: 1px solid #ffb3b3;
-    border-radius: 4px;
-    color: #a94442;
-  }
-  .flashes li {
-    margin: 5px 0;
-  }
-  img {
-    max-width: 100%;
-    height: auto;
-    border-radius: 4px;
-  }
-  

templates/index.html

@@ -1,43 +0,0 @@
-<!-- templates/index.html -->
-<!DOCTYPE html>
-<html>
-<head>
-    <title>OCR App</title>
-    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
-</head>
-<body>
-  <div class="container">
-    <h1>Image Text Extraction</h1>
-    <p>Upload an image to extract text using PaddleOCR.</p>
-
-    {% with messages = get_flashed_messages() %}
-      {% if messages %}
-        <ul class="flashes">
-        {% for message in messages %}
-          <li>{{ message }}</li>
-        {% endfor %}
-        </ul>
-      {% endif %}
-    {% endwith %}
-
-    <form method="POST" enctype="multipart/form-data">
-      <input type="file" name="image" accept="image/*" required>
-      <button type="submit">Extract Text</button>
-    </form>
-
-    {% if extracted_text %}
-      <div class="result">
-        <h2>Extracted Text:</h2>
-        <pre>{{ extracted_text }}</pre>
-      </div>
-    {% endif %}
-
-    {% if image_file %}
-      <div class="image-preview">
-        <h2>Uploaded Image:</h2>
-        <img src="{{ url_for('static', filename='uploads/' + image_file) }}" alt="Uploaded Image">
-      </div>
-    {% endif %}
-  </div>
-</body>
-</html>