Update app.py

app.py

@@ -1,48 +1,235 @@
+
+import os
+from paddleocr import PaddleOCR
+from PIL import Image, ImageEnhance
 import gradio as gr
-from transformers import DetrImageProcessor, DetrForObjectDetection
-import torch
-from PIL import Image, ImageDraw
+import pandas as pd
+import re
+from simple_salesforce import Salesforce
+
+# 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": "Paymentstatus__c",
+    "Invoicedate": "Manufacturedate__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_Number__c",
+    "coolingmethod": "coolingmethod__c"
+}
+
+# Salesforce credentials
+SALESFORCE_USERNAME = "venkatramana@sandbox.com"
+SALESFORCE_PASSWORD = "Venkat12345@"
+SALESFORCE_SECURITY_TOKEN = "GhcJJmjBEefdnukJoz4CAQlR"
+
+# Initialize PaddleOCR
+ocr = PaddleOCR(use_angle_cls=True, lang='en')
+
+# Environment variable for the Excel file path
+EXCEL_FILE_PATH = os.getenv("EXCEL_FILE_PATH", "DataStorage.xlsx")
+
+# Function to extract text using PaddleOCR
+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)
+
+# Function to find attributes and their values
+def find_attributes(text):
+    structured_data = {}
+    for readable_attr, sf_attr in ATTRIBUTE_MAPPING.items():
+        pattern = rf"{re.escape(readable_attr)}[:\-]?\s*(.+)"  # Match the attribute and capture its value
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            structured_data[sf_attr] = match.group(1).strip()
+    return structured_data
+
+# Function to sanitize numeric values
+def sanitize_numeric(value):
+    try:
+        if isinstance(value, (int, float)):
+            return value
+        if '/' in value:  # Handle fraction strings like "1/2"
+            numerator, denominator = value.split('/')
+            return float(numerator) / float(denominator)
+        sanitized = re.sub(r'[^\d\.\-]', '', value)  # Remove non-numeric characters
+        return float(sanitized) if sanitized else None
+    except (ValueError, ZeroDivisionError):
+        return None
+
+# Function to save structured data to the constant Excel file
+def save_to_excel(data):
+    if not data:
+        return "No data to save."
+
+    if not os.path.exists(EXCEL_FILE_PATH):
+        df = pd.DataFrame([data])
+        df.to_excel(EXCEL_FILE_PATH, index=False, engine="openpyxl")
+    else:
+        existing_df = pd.read_excel(EXCEL_FILE_PATH, engine="openpyxl")
+        new_data_df = pd.DataFrame([data])
+        updated_df = pd.concat([existing_df, new_data_df], ignore_index=True)
+        updated_df.to_excel(EXCEL_FILE_PATH, index=False, engine="openpyxl")
+
+    return EXCEL_FILE_PATH
+
+# Function to handle entry mode
+def add_stock_to_venkataramana(data):
+    try:
+        sf = Salesforce(
+            username=SALESFORCE_USERNAME,
+            password=SALESFORCE_PASSWORD,
+            security_token=SALESFORCE_SECURITY_TOKEN,
+        )
+
+        object_name = "VENKATA_RAMANA_MOTORS__c"
+        sf_object = sf.__getattr__(object_name)
+
+        schema = sf_object.describe()
+        valid_fields = {field["name"] for field in schema["fields"]}
 
-# Load the processor and model for object detection
-processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
-model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
+        filtered_record = {k: v for k, v in data.items() if k in valid_fields and v is not None}
+        sf_object.create(filtered_record)
+        return f"Data successfully added to {object_name}."
+    except Exception as e:
+        return f"Error adding stock to VENKATA_RAMANA_MOTORS__c: {str(e)}"
+
+# Function to handle exit mode
+def subtract_stock_from_inventory(data):
+    try:
+        sf = Salesforce(
+            username=SALESFORCE_USERNAME,
+            password=SALESFORCE_PASSWORD,
+            security_token=SALESFORCE_SECURITY_TOKEN,
+        )
+
+        object_name = "Inventory_Management__c"
+        sf_object = sf.__getattr__(object_name)
+
+        product_name = data.get("Productname__c")
+        quantity = data.get("Quantity__c", 0)
+
+        if not product_name:
+            return "Product name is missing in the data. Cannot update stock."
+
+        # Query existing stock record
+        query = f"SELECT Id, Quantity_Sold__c FROM {object_name} WHERE Product_Name__c = '{product_name}' LIMIT 1"
+        response = sf.query(query)
+
+        if not response["records"]:
+            return f"No stock found for product '{product_name}'. Cannot update stock."
 
-# Prediction function
-def predict_image(image: Image.Image):
+        record_id = response["records"][0]["Id"]
+        current_quantity_sold = response["records"][0].get("Quantity_Sold__c", 0)
+
+        # Update the quantity sold
+        updated_quantity_sold = current_quantity_sold + quantity
+
+        sf_object.update(record_id, {"Quantity_Sold__c": updated_quantity_sold})
+
+        return f"Stock updated successfully in exit mode. Quantity sold for product '{product_name}': {updated_quantity_sold}."
+    except Exception as e:
+        return f"Error updating stock in Inventory_Management__c: {str(e)}"
+
+# Unified function for processing
+def process_image(image, quantity, mode):
     try:
-        # Step 1: Preprocess the image with padding and ensure it is batched
-        inputs = processor(images=image, return_tensors="pt", padding=True)
+        extracted_text = extract_text(image)
+        attributes = find_attributes(extracted_text)
+        attributes["Quantity__c"] = sanitize_numeric(quantity)
+
+        if not attributes:
+            return "No attributes found in the image.", None
 
-        # Step 2: Run inference (no gradients)
-        with torch.no_grad():
-            outputs = model(**inputs)
+        numbered_output = "\n".join(
+            [f"{key.replace('__c', '')}: {value}" for key, value in attributes.items()]
+        )
 
-        # Step 3: Post-process the outputs
-        target_sizes = torch.tensor([image.size[::-1]])  # image size reversed to match model format
-        results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.5)[0]
+        file_path = save_to_excel(attributes)
 
-        # Step 4: Draw bounding boxes on the image
-        draw = ImageDraw.Draw(image)
-        for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-            box = [round(i, 2) for i in box.tolist()]
-            draw.rectangle(box, outline="red", width=2)
-            draw.text((box[0], box[1]), f"{model.config.id2label[label.item()]}: {round(score.item(), 3)}", fill="red")
+        if mode == "Entry":
+            message = add_stock_to_venkataramana(attributes)
+        elif mode == "Exit":
+            message = subtract_stock_from_inventory(attributes)
+        else:
+            message = "Invalid mode. Please select Entry or Exit."
 
-        # Step 5: Return the processed image and a success message
-        return image, "Object detection complete."
+        return f"{numbered_output}\n\n{message}", file_path
 
     except Exception as e:
-        return None, f"Error: {str(e)}"
-
-# Gradio interface for user interaction
-iface = gr.Interface(
-    fn=predict_image, 
-    inputs=gr.Image(type="pil"),  # Image input type
-    outputs=[gr.Image(type="pil"), gr.Textbox(label="Status")],  # Image output with bounding boxes
-    live=True,  # Option to show live updates as the image is processed
-    title="Object Detection with DETR",
-    description="Upload an image, and the model will detect objects and draw bounding boxes on it."
+        return f"Error during processing: {str(e)}", None
+
+interface = gr.Interface(
+    fn=process_image,
+    inputs=[
+        gr.Image(type="numpy"),
+        gr.Number(label="Quantity", value=1, interactive=True),
+        gr.Dropdown(label="Mode", choices=["Entry", "Exit"], value="Entry")
+    ],
+    outputs=[
+        gr.Text(label="Image Data Viewer"),
+        gr.File(label="Data Storage Manager")
+    ],
+    title="Processing - VENKATARAMANA MOTORS",
+    description="Process images to update stock in Salesforce and save to Excel.",
 )
 
-# Launch the app
-iface.launch()
+if __name__ == "__main__":
+    interface.launch(share=True)
+