Update app.py

app.py

@@ -1,11 +1,13 @@
 import os
 from paddleocr import PaddleOCR
-from PIL import Image, ImageEnhance
+from PIL import Image
 import gradio as gr
-import pandas as pd
+import requests
 import re
-from fuzzywuzzy import process
 from simple_salesforce import Salesforce
+import pandas as pd
+import matplotlib.pyplot as plt
+from io import BytesIO
 
 # Attribute mappings: readable names to Salesforce API names
 ATTRIBUTE_MAPPING = {
@@ -71,13 +73,6 @@ ATTRIBUTE_MAPPING = {
     "coolingmethod": "coolingmethod__c"
 }
 
-# List of product names to match
-PRODUCT_NAMES = [
-    "Centrifugal mono block pump", "SINGLE PHASE MOTOR STARTER", "EasyPact EZC 100",
-    "Openwell Submersible Pumpset", "Electric Motor", "Self Priming Pump",
-    # Add more products here
-]
-
 # Salesforce credentials
 SALESFORCE_USERNAME = "venkatramana@sandbox.com"
 SALESFORCE_PASSWORD = "Venkat12345@"
@@ -92,83 +87,131 @@ 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 = "\n".join([line[1][0] for line in result[0]])
-    return extracted_text
+    extracted_text = []
+    for line in result[0]:
+        extracted_text.append(line[1][0])
+    extracted_text_str = "\n".join(extracted_text)
+    print("Extracted Text:", extracted_text_str)  # Debug: Log extracted text
+    return extracted_text_str
 
 # Function to find product name from the predefined list using fuzzy matching
 def match_product_name(text):
-    best_match, best_score = None, 0
+    best_match = None
+    best_score = 0
+
+    # Split text into lines for detailed matching
     for line in text.split("\n"):
         match, score = process.extractOne(line, PRODUCT_NAMES)
-        if score > best_score:
-            best_match, best_score = match, score
-    return best_match if best_score >= 70 else None
+        if score > best_score:  # Retain the best match with the highest score
+            best_match = match
+            best_score = score
+
+    print(f"Best Match: {best_match}, Score: {best_score}")  # Debug: Log the best matching details
+    return best_match if best_score >= 70 else None  # Threshold of 70 for matching
 
 # Function to find attributes and their values
 def find_attributes(text):
     structured_data = {}
+
+    # Match and add product name
+    matched_product = match_product_name(text)
+    if matched_product:
+        structured_data["Productname__c"] = matched_product
+
     for readable_attr, sf_attr in ATTRIBUTE_MAPPING.items():
-        pattern = rf"{re.escape(readable_attr)}[:\-]?\s*(.+)"
+        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
 
-# Unified function for processing images
-def process_image(image, quantity, mode, entry_type):
-    try:
-        extracted_text = extract_text(image)
-        attributes = find_attributes(extracted_text)
-        attributes["Quantity__c"] = quantity
-        numbered_output = "\n".join([f"{k}: {v}" for k, v in attributes.items()])
-        return f"Extracted Text:\n{extracted_text}\n\nAttributes:\n{numbered_output}", None
-    except Exception as e:
-        return f"Error: {str(e)}", None
+    return structured_data
 
-# Function to pull stock data from Salesforce
-def pull_stock_data():
+# Function to pull data from Salesforce MotorDataAPI
+def pull_data_from_motor_api():
     try:
         sf = Salesforce(
             username=SALESFORCE_USERNAME,
             password=SALESFORCE_PASSWORD,
             security_token=SALESFORCE_SECURITY_TOKEN,
         )
-        stock_data = sf.apexecute("MotorDataAPI", method="GET")
-        return stock_data
+
+        motor_data = sf.apexecute("MotorDataAPI/", method="GET")
+        return motor_data  # API returns the list of records
     except Exception as e:
+        print("Error pulling data from MotorDataAPI:", e)
         return f"Error: {str(e)}"
 
-# Function to format Salesforce data for display
+# Function to format Salesforce data into a DataFrame
 def format_salesforce_data():
-    data = pull_stock_data()
-    if isinstance(data, list):
-        return "\n".join([f"{item.get('Product_Name__c', 'N/A')} - {item.get('Stock', 'N/A')}" for item in data])
-    return data
-
-# Gradio interfaces
-interface = gr.TabbedInterface(
-    [
+    try:
+        data = pull_data_from_motor_api()
+        if isinstance(data, list):
+            df = pd.DataFrame(data)
+            df = df[["Product_Name__c", "Modal_Name__c", "Current_Stocks__c"]]
+            return df
+        else:
+            return None
+    except Exception as e:
+        print("Error in format_salesforce_data:", e)
+        return None
+
+# Function to generate a bar graph from Salesforce data
+def generate_bar_graph(df):
+    try:
+        fig, ax = plt.subplots(figsize=(10, 6))
+        df.plot(kind='bar', x="Product_Name__c", y="Current_Stocks__c", ax=ax, legend=False)
+        ax.set_title("Stock Distribution by Product Name")
+        ax.set_xlabel("Product Name")
+        ax.set_ylabel("Current Stocks")
+        plt.xticks(rotation=45, ha="right")
+        buffer = BytesIO()
+        plt.savefig(buffer, format="png")
+        buffer.seek(0)
+        img = Image.open(buffer)
+        return img
+    except Exception as e:
+        print("Error generating bar graph:", e)
+        return None
+
+# Gradio Interface
+def app():
+    df = format_salesforce_data()
+    table_component = None
+    bar_graph_component = None
+
+    if df is not None:
+        table_component = df.to_html(index=False)
+        bar_graph_image = generate_bar_graph(df)
+        if bar_graph_image:
+            bar_graph_component = bar_graph_image
+
+    return gr.TabbedInterface([
         gr.Interface(
             fn=process_image,
             inputs=[
                 gr.Image(type="numpy"),
-                gr.Number(label="Quantity"),
-                gr.Dropdown(label="Mode", choices=["Entry", "Exit"]),
-                gr.Radio(label="Entry Type", choices=["Sales", "Non-Sales"]),
+                gr.Number(label="Quantity", value=1, interactive=True),
+                gr.Dropdown(label="Mode", choices=["Entry", "Exit"], value="Entry"),
+                gr.Radio(label="Entry Type", choices=["Sales", "Non-Sales"], value="Sales", interactive=True)
+            ],
+            outputs=[
+                gr.Text(label="Image Data Viewer"),
+                gr.File(label="Data Storage Manager")
             ],
-            outputs="text",
-            title="Process Image"
+            title="Processing - VENKATA RAMANA MOTORS",
+            description="Process images for Entry (Sales/Non-Sales) or Exit (Sales/Non-Sales) mode to update stock.",
         ),
         gr.Interface(
-            fn=format_salesforce_data,
+            fn=lambda: (table_component, bar_graph_component),
             inputs=[],
-            outputs="text",
-            title="Stock Updates"
-        ),
-    ],
-    title="VENKATA RAMANA MOTORS Dashboard",
-    description="OCR and Salesforce integration for motor inventory."
-)
+            outputs=[
+                gr.HTML(label="Salesforce Data Table"),
+                gr.Image(type="pil", label="Stock Distribution Bar Graph")
+            ],
+            title="Salesforce Data",
+            description="View structured Salesforce data as a table and bar graph."
+        )
+    ], ["Processing", "Salesforce Data"])
 
 if __name__ == "__main__":
-    interface.launch(share=True)
+    app().launch(share=True)