Update app.py

app.py

@@ -1,49 +1,272 @@
-from flask import Flask, request, jsonify
-from transformers import pipeline
-import base64
-from PIL import Image
-import io
 import os
-import torch
-import time
+from paddleocr import PaddleOCR
+from PIL import Image
+import gradio as gr
+import requests
+import re
+from simple_salesforce import Salesforce
+import pandas as pd
+import matplotlib.pyplot as plt
+from io import BytesIO
+from fuzzywuzzy import process
+import base64
+from flask import Flask, request, jsonify
 
-# Initialize Flask app
+# Initialize Flask App for camera input
 app = Flask(__name__)
 
-# Configure device (use GPU if available)
-device = 0 if torch.cuda.is_available() else -1
+# Salesforce credentials
+SALESFORCE_USERNAME = "venkatramana@sandbox.com"
+SALESFORCE_PASSWORD = "Venkat12345@"
+SALESFORCE_SECURITY_TOKEN = "GhcJJmjBEefdnukJoz4CAQlR"
+
+# Initialize PaddleOCR
+ocr = PaddleOCR(use_angle_cls=True, lang='en')
+
+# Product names list
+PRODUCT_NAMES = [
+    "Centrifugal mono block pump", "SINGLE PHASE MOTOR STARTER", "EasyPact EZC 100",
+    "Openwell Submersible Pumpset", "Electric Motor", "Self Priming Pump",
+    "Control panel for single phase submersible pumps", "MOTOR", "Submersible pump set",
+    "Fusion submersible pump set", "DCT", "Shock proof water proof", "CG COMMERCIAL MOTORS", "Fusion",
+    "control panel for single phase submerisible pumps",
+    "single phase digital starter dry run and timer panel", "5HP AV1 XL Kirloskar Pump",
+    "Phase stainless steel submersible pump", "Submersible pump", "WB15X",
+    "Vtype self priming pump", "SP SHINE DISC", "havells submersible pump",
+    "Havells open well Submersible pump", "Bertolini pump CK3 90pp",
+    "WPA 772 Water Pump Assy", "bertolini TTL triplex high pressure plunger pumps",
+    "Generic plunger high pressure pump", "Apple Normal, Banana",
+    "Cast Iron KSb centrifugal pump", "5.5kw Water Pump",
+    "KSB reliable i line centrifuged pumps", "Apple Normal, Orange, Banana",
+    "Positive API 6745 hydraulic diaphragm pump", "1/2 inch Fuel Hose Pipe", "Kirloskar Water Pump",
+    "Rotodel motor pump", "PVC Electrical Insulation Materials",
+    "Electric kirloskar domestic water pump", "Electrical Insulation Materials",
+    "sellowell motor pump", "bhupathi submersible pump set",
+    "Flowshine Submersible pump set", "Index submersible pump",
+    "Wintoss Plastic Electric Switch Board", "Electric 18 watt ujagar cooler pump",
+    "Generator Service", "LG WM FHT1207ZWL, LG REF GL-S292RSCY",
+    "Water tank, Filters, Water Pump", "MS Control Submersible Panel",
+    "Centrifugal Monoblock Pumps", "Electric Motor with Pump BodyBlue and White",
+    "Various Repair and Maintenance Parts", "Earthmax Pump",
+    "Water Tank, Filters, Water Pump", "Centrifugal Water Pump for Agriculture",
+    "mono block pumps"
+]
+
+# Attribute mappings: readable names to Salesforce API names
+ATTRIBUTE_MAPPING = {
+    "Product name": "Productname__c",
+    "Colour": "Colour__c",
+    "Motortype": "Motortype__c",
+    "Frequency": "Frequency__c",
+    "Grossweight": "Grossweight__c",
+    "Ratio": "Ratio__c",
+    "MotorFrame": "Motorframe__c",
+    "Model": "Model__c",
+    "Speed": "Speed__c",
+    "Quantity": "Quantity__c",
+    "Voltage": "Voltage__c",
+    "Material": "Material__c",
+    "Type": "Type__c",
+    "Horsepower": "Horsepower__c",
+    "Consignee": "Consignee__c",
+    "LOT": "LOT__c",
+    "Stage": "Stage__c",
+    "Outlet": "Outlet__c",
+    "Serialnumber": "Serialnumber__c",
+    "HeadSize": "Headsize__c",
+    "Deliverysize": "Deliverysize__c",
+    "Phase": "Phase__c",
+    "Size": "Size__c",
+    "MRP": "MRP__c",
+    "Usebefore": "Usebefore__c",
+    "Height": "Height__c",
+    "MaximumDischarge Flow": "Maximumdischargeflow__c",
+    "DischargeRange": "Dischargeflow__c",
+    "Assembledby": "Manufacturer__c",
+    "Manufacturedate": "Manufacturedate__c",
+    "Companyname": "Companyname__c",
+    "Customercarenumber": "Customercarenumber__c",
+    "SellerAddress": "Selleraddress__c",
+    "Selleremail": "Selleremail__c",
+    "GSTIN": "GSTIN__c",
+    "Totalamount": "Totalamount__c",
+    "Paymentstatus": "Paymentstatus__c",
+    "Paymentmethod": "Paymentmethod__c",
+    "Invoicedate": "Invoicedate__c",
+    "Warranty": "Warranty__c",
+    "Brand": "Brand__c",
+    "Motorhorsepower": "Motorhorsepower__c",
+    "Power": "Power__c",
+    "Motorphase": "Motorphase__c",
+    "Enginetype": "Enginetype__c",
+    "Tankcapacity": "Tankcapacity__c",
+    "Head": "Head__c",
+    "Usage/Application": "Usage_Application__c",
+    "Volts": "volts__c",
+    "Hertz": "Hertz__c",
+    "Frame": "frame__c",
+    "Mounting": "Mounting__c",
+    "Tollfreenumber": "Tollfreenumber__c",
+    "Pipesize": "Pipesize__c",
+    "Manufacturer": "Manufacturer__c",
+    "Office": "Office__c",
+    "SRnumber": "SRnumber__c",
+    "TypeOfEndUse": "TypeOfEndUse__c",
+    "Model Name": "Model_Name__c",
+    "coolingmethod": "coolingmethod__c"
+}
+
+# Function to process the image and extract text
+@app.route('/upload-image', methods=['POST'])
+def upload_image():
+    try:
+        data = request.get_json()
+        image_base64 = data.get('image')
+
+        if not image_base64:
+            return jsonify({"success": False, "message": "No image data received."})
 
-# Set absolute path to the model directory
-model_path = os.path.abspath("./saved_model")
+        # Decode base64 image
+        image_data = base64.b64decode(image_base64.split(",")[1])
+        image = Image.open(BytesIO(image_data))
 
-# Preload model and log loading time
-start_time = time.time()
-print("Loading model...")
-model = pipeline("image-classification", model=model_path, device=device)  # Load from absolute path
-print(f"Model loaded in {time.time() - start_time:.2f} seconds")
+        # OCR Extraction
+        ocr_result = ocr.ocr(image)
+        extracted_text = "\n".join([line[1][0] for line in ocr_result[0]])
 
-@app.route('/process_image', methods=['POST'])
-def process_image():
+        if not extracted_text:
+            return jsonify({"success": False, "message": "No text extracted from the image."})
+
+        return jsonify({"success": True, "result": extracted_text})
+    except Exception as e:
+        return jsonify({"success": False, "message": str(e)})
+
+# Function to process image using Gradio and Salesforce integration
+def process_image(image, mode, entry_type, quantity):
     try:
-        # Parse base64 image from the request
-        data = request.json.get("image")
-        if not data:
-            return jsonify({"error": "No image provided"}), 400
+        # Extract text from the image
+        extracted_text = extract_text(image)
+        if not extracted_text:
+            return "No text detected in the image.", None
+
+        # Match product name
+        product_name = match_product_name(extracted_text)
+        attributes = extract_attributes(extracted_text)
+        if product_name:
+            attributes["Product name"] = product_name
+
+        # Interact with Salesforce
+        message = interact_with_salesforce(mode, entry_type, quantity, extracted_text)
+
+        numbered_output = "\n".join([f"{key}: {value}" for key, value in attributes.items()])
+        return f"Extracted Text:\n{extracted_text}\n\nAttributes and Values:\n{numbered_output}", message
+    except Exception as e:
+        return f"Error processing image: {str(e)}", None
 
-        # Decode the base64 image
-        image_data = base64.b64decode(data.split(",")[1])
-        image = Image.open(io.BytesIO(image_data))
+# Helper functions for OCR and Salesforce interaction
+def extract_text(image):
+    result = ocr.ocr(image)
+    extracted_text = []
+    for line in result[0]:
+        extracted_text.append(line[1][0])
+    return "\n".join(extracted_text)
 
-        # Convert image to RGB
-        image = image.convert("RGB")
+def match_product_name(extracted_text):
+    best_match = None
+    best_score = 0
+    for line in extracted_text.split("\n"):
+        match, score = process.extractOne(line, PRODUCT_NAMES)
+        if score > best_score:
+            best_match = match
+            best_score = score
+    return best_match if best_score >= 70 else None
 
-        # Run inference
-        predictions = model(image)
+def extract_attributes(extracted_text):
+    attributes = {}
+    for readable_attr, sf_attr in ATTRIBUTE_MAPPING.items():
+        pattern = rf"{re.escape(readable_attr)}[:\-]?\s*(.+)"
+        match = re.search(pattern, extracted_text, re.IGNORECASE)
+        if match:
+            attributes[readable_attr] = match.group(1).strip()
+    return attributes
 
-        # Return predictions
-        return jsonify({"predictions": predictions})
+def interact_with_salesforce(mode, entry_type, quantity, extracted_text):
+    try:
+        sf = Salesforce(
+            username=SALESFORCE_USERNAME,
+            password=SALESFORCE_PASSWORD,
+            security_token=SALESFORCE_SECURITY_TOKEN
+        )
+        # Add logic for Salesforce interaction based on mode and entry_type
+        # Simplified example:
+        return "Successfully interacted with Salesforce."
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        return f"Error interacting with Salesforce: {str(e)}"
+
+# Gradio Interface
+
+def create_interface():
+    return gr.Interface(
+        fn=process_image,
+        inputs=[
+            gr.HTML("""
+            <h1>Camera Input</h1>
+            <video id=\"rear-camera\" autoplay></video>
+            <button id=\"capture-btn\">Capture</button>
+            <canvas id=\"camera-canvas\" style=\"display:none;\"></canvas>
+            <p id=\"status\">Status: Ready</p>
+            <script>
+                const statusElement = document.getElementById(\"status\");
+                navigator.mediaDevices.getUserMedia({
+                    video: { facingMode: \"environment\" }
+                }).then(stream => {
+                    const videoElement = document.getElementById(\"rear-camera\");
+                    videoElement.srcObject = stream;
+                    const captureBtn = document.getElementById(\"capture-btn\");
+                    const canvas = document.getElementById(\"camera-canvas\");
+                    const ctx = canvas.getContext(\"2d\");
+
+                    captureBtn.addEventListener(\"click\", () => {
+                        statusElement.innerText = \"Status: Capturing...\";
+                        canvas.width = videoElement.videoWidth;
+                        canvas.height = videoElement.videoHeight;
+                        ctx.drawImage(videoElement, 0, 0, canvas.width, canvas.height);
+
+                        const imageData = canvas.toDataURL(\"image/png\");
+                        fetch(\"/upload-image\", {
+                            method: \"POST\",
+                            body: JSON.stringify({ image: imageData }),
+                            headers: { \"Content-Type\": \"application/json\" }
+                        }).then(response => response.json()).then(data => {
+                            if (data.success) {
+                                statusElement.innerText = \"Status: Image scanned successfully!\";
+                                console.log(\"OCR Result:\", data.result);
+                            } else {
+                                statusElement.innerText = \"Status: Error in processing image.\";
+                                console.error(\"Error:\", data.message);
+                            }
+                        }).catch(err => {
+                            statusElement.innerText = \"Status: Failed to upload image.\";
+                            console.error(\"Error uploading image:\", err);
+                        });
+                    });
+                }).catch(error => {
+                    console.error(\"Error accessing the rear camera:\", error);
+                    alert(\"Unable to access the rear camera. Please check permissions.\");
+                });
+            </script>
+            """),
+            gr.Dropdown(label="Mode", choices=["Entry", "Exit"], value="Entry"),
+            gr.Radio(label="Entry Type", choices=["Sales", "Non-Sales"], value="Sales"),
+            gr.Number(label="Quantity", value=1, interactive=True)
+        ],
+        outputs=[
+            gr.Text(label="Extracted Text and Attributes"),
+            gr.Text(label="Salesforce Interaction Result")
+        ],
+        title="Salesforce Export",
+        description="Use your camera to scan an image and process data for Salesforce.")
 
-if __name__ == '__main__':
-    app.run(debug=False, host="0.0.0.0", port=5000)
+if __name__ == "__main__":
+    create_interface().launch(share=True)
+    app.run(debug=True)