Update app.py

app.py

@@ -15,6 +15,34 @@ SALESFORCE_USERNAME = "venkatramana@sandbox.com"
 SALESFORCE_PASSWORD = "Venkat12345@"
 SALESFORCE_SECURITY_TOKEN = "GhcJJmjBEefdnukJoz4CAQlR"
 
+# 📌 Product Name List for Fuzzy Matching
+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",
+    "Flowshine Submersible pump", "5HP AV1 XL Kirloskar Pump",
+    "Submersible pump", "WB15X", "Havells open well Submersible pump",
+    "Bertolini pump CK3 90pp", "Water Tank, Filters, Water Pump",
+    "Earthmax Pump", "Electric Motor with Pump BodyBlue and White",
+]
+
+# 📌 Attribute Mapping (Readable Name → Salesforce API Name)
+ATTRIBUTE_MAPPING = {
+    "Product name": "Product_Name__c",
+    "Model": "Model__c",
+    "Quantity": "Quantity__c",
+    "Voltage": "Voltage__c",
+    "Horsepower": "Horsepower__c",
+    "Serial Number": "Serialnumber__c",
+    "Warranty": "Warranty__c",
+    "Brand": "Brand__c",
+    "Motor Phase": "Motorphase__c",
+    "Size": "Size__c",
+    "Frame": "Frame__c",
+    "Usage": "Usage_Application__c",
+}
+
 # 🧠 Initialize PaddleOCR
 ocr = PaddleOCR(use_angle_cls=True, lang='en')
 
@@ -26,64 +54,28 @@ def extract_text(image):
         extracted_text.append(line[1][0])
     return "\n".join(extracted_text)
 
-# Function to fetch and return Salesforce data
-def fetch_salesforce_data():
-    try:
-        sf = Salesforce(
-            username=SALESFORCE_USERNAME,
-            password=SALESFORCE_PASSWORD,
-            security_token=SALESFORCE_SECURITY_TOKEN,
-            domain='login'
-        )
-
-        # SOQL Query
-        soql_query = """
-            SELECT Product_Name__c, Modal_Name__c, Current_Stocks__c 
-            FROM Inventory_Management__c
-            LIMIT 100
-        """
-        response = sf.query(soql_query)
-        records = response.get('records', [])
-
-        if not records:
-            return None, None
-
-        df = pd.DataFrame(records)
-        df.rename(columns={
-            'Product_Name__c': 'Product Name',
-            'Modal_Name__c': 'Model Name',
-            'Current_Stocks__c': 'Current Stocks'
-        }, inplace=True)
-        df.drop(columns=['attributes'], inplace=True, errors='ignore')
-
-        return df, generate_bar_graph(df)
-
-    except Exception as e:
-        return None, None
-
-# Function to generate a bar graph from Salesforce data
-def generate_bar_graph(df):
-    try:
-        fig, ax = plt.subplots(figsize=(12, 8))
-        df.plot(kind='bar', x="Product Name", y="Current Stocks", 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", fontsize=10)
-        plt.tight_layout()
-        buffer = BytesIO()
-        plt.savefig(buffer, format="png")
-        buffer.seek(0)
-        return Image.open(buffer)
-    except Exception as e:
-        return None
-
-# Function to generate Salesforce data table and graph
-def generate_salesforce_data():
-    df, graph = fetch_salesforce_data()
-    if df is not None:
-        return df.to_html(index=False), graph
-    return "<p>No Data Available</p>", None
+# Function to match product name using fuzzy matching
+def match_product_name(extracted_text):
+    best_match, best_score = None, 0
+    for line in extracted_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  # Threshold: 70
+
+# Function to extract attributes from text
+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
+
+# Function to filter attributes for valid Salesforce fields
+def filter_valid_attributes(attributes, valid_fields):
+    return {ATTRIBUTE_MAPPING[key]: value for key, value in attributes.items() if ATTRIBUTE_MAPPING[key] in valid_fields}
 
 # Function to export extracted data to Salesforce
 def export_to_salesforce(mode, entry_type, quantity, extracted_text):
@@ -95,47 +87,46 @@ def export_to_salesforce(mode, entry_type, quantity, extracted_text):
         )
 
         # Determine Object & Field Mapping
-        object_name = None
-        product_field_name = "Product_Name__c"
-        model_field_name = "Modal_Name__c"
-        field_name = None
+        object_name, field_name = None, None
 
         if mode == "Entry":
-            if entry_type == "Sales":
-                object_name = "VENKATA_RAMANA_MOTORS__c"
-                field_name = "Quantity__c"
-            elif entry_type == "Non-Sales":
-                object_name = "UNBILLING_DATA__c"
-                field_name = "TotalQuantity__c"
+            object_name = "Inventory_Management__c" if entry_type == "Sales" else "Un_Billable__c"
+            field_name = "Quantity__c"
         elif mode == "Exit":
-            if entry_type == "Sales":
-                object_name = "Inventory_Management__c"
-                field_name = "Quantity_Sold__c"
-            elif entry_type == "Non-Sales":
-                object_name = "Un_Billable__c"
-                field_name = "Sold_Out__c"
+            object_name = "Inventory_Management__c" if entry_type == "Sales" else "Un_Billable__c"
+            field_name = "Quantity_Sold__c"
 
         if not object_name or not field_name:
-            return "Invalid mode or entry type."
+            return "❌ Invalid mode or entry type."
+
+        # Extract Product Name & Attributes
+        product_name = match_product_name(extracted_text)
+        attributes = extract_attributes(extracted_text)
 
-        # Extract Product Name
-        product_name = extracted_text.split("\n")[0] if extracted_text else None
         if not product_name:
-            return "❌ Error: No product name found in extracted text."
+            return "❌ No matching product found."
+
+        attributes["Product name"] = product_name
+
+        # Validate Salesforce fields
+        sf_object = sf.__getattr__(object_name)
+        schema = sf_object.describe()
+        valid_fields = {field["name"] for field in schema["fields"]}
+
+        filtered_attributes = filter_valid_attributes(attributes, valid_fields)
+        filtered_attributes[field_name] = quantity
 
         # Check if record exists
-        query = f"SELECT Id, {field_name} FROM {object_name} WHERE {product_field_name} = '{product_name}' LIMIT 1"
+        query = f"SELECT Id FROM {object_name} WHERE Product_Name__c = '{product_name}' LIMIT 1"
         response = sf.query(query)
 
         if response["records"]:
-            # Update existing record
             record_id = response["records"][0]["Id"]
-            sf.__getattr__(object_name).update(record_id, {field_name: quantity})
-            return f"✅ Updated record for product '{product_name}' in {object_name}. New {field_name}: {quantity}."
+            sf_object.update(record_id, filtered_attributes)
+            return f"✅ Updated record for '{product_name}' in {object_name}."
         else:
-            # Create new record
-            sf.__getattr__(object_name).create({product_field_name: product_name, field_name: quantity})
-            return f"✅ Data successfully exported to Salesforce object {object_name}."
+            sf_object.create(filtered_attributes)
+            return f"✅ Created new record in {object_name} for '{product_name}'."
 
     except Exception as e:
         return f"❌ Error exporting data to Salesforce: {str(e)}"
@@ -144,10 +135,10 @@ def export_to_salesforce(mode, entry_type, quantity, extracted_text):
 def process_image(image, mode, entry_type, quantity):
     extracted_text = extract_text(image)
     if not extracted_text:
-        return "No text detected in the image.", None
+        return "❌ No text detected in the image.", None
 
     result = export_to_salesforce(mode, entry_type, quantity, extracted_text)
-    return f"Extracted Text:\n{extracted_text}", result
+    return f"📜 Extracted Text:\n{extracted_text}", result
 
 # Gradio App
 def app():
@@ -163,7 +154,7 @@ def app():
                     quantity_input = gr.Number(label="🔢 Quantity", value=1, interactive=True)
 
                 with gr.Column():
-                    image_view = gr.Text(label="📜 Image Data Viewer", interactive=False)
+                    image_view = gr.Text(label="📜 Extracted Data", interactive=False)
                     result_output = gr.Text(label="📝 Salesforce Export Result", interactive=False)
                     submit_button = gr.Button("🔍 Process & Export")