Update app.py

app.py

@@ -1,13 +1,16 @@
 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
+from fuzzywuzzy import process
 
-# Attribute mappings: readable names to Salesforce API names
+#📌 Attribute mappings: readable names to Salesforce API names
 ATTRIBUTE_MAPPING = {
     "Product name": "Productname__c",
     "Colour": "Colour__c",
@@ -76,9 +79,9 @@ 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",
+    "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",
+    "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",
@@ -86,7 +89,7 @@ PRODUCT_NAMES = [
     "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",
+    "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",
@@ -100,181 +103,459 @@ PRODUCT_NAMES = [
     "mono block pumps"
 ]
 
-# Salesforce credentials
+#📌 Salesforce credentials
 SALESFORCE_USERNAME = "venkatramana@sandbox.com"
 SALESFORCE_PASSWORD = "Venkat12345@"
 SALESFORCE_SECURITY_TOKEN = "GhcJJmjBEefdnukJoz4CAQlR"
 
-# Initialize PaddleOCR
+#🧠 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])
-    print("Extracted Text:", "\n".join(extracted_text))  # Debug: Log extracted text
     return "\n".join(extracted_text)
 
-# Function to find product name from the predefined list using fuzzy matching
-def match_product_name(text):
-    print("Matching Text:", text)  # Debug: Log the text being matched
-    best_match, score = process.extractOne(text, PRODUCT_NAMES)
-    print(f"Best Match: {best_match}, Score: {score}")  # Debug: Log matching details
-    if score >= 70:  # Lowered threshold
-        return best_match
-    return None
+# Function to match product name using fuzzy matching
+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
 
-# Function to find attributes and their values
-def find_attributes(text):
-    structured_data = {}
+    return best_match if best_score >= 70 else None  # Threshold of 70 for a match
 
-    # Match and add product name
-    matched_product = match_product_name(text)
-    if matched_product:
-        structured_data["Productname__c"] = matched_product
+# Function to extract attributes and their values
+def extract_attributes(extracted_text):
+    attributes = {}
 
     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)
+        pattern = rf"{re.escape(readable_attr)}[:\-]?\s*(.+)"
+        match = re.search(pattern, extracted_text, re.IGNORECASE)
         if match:
-            structured_data[sf_attr] = match.group(1).strip()
+            attributes[readable_attr] = match.group(1).strip()
 
-    return structured_data
+    return attributes
 
-# 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."
+# 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}
 
-    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):
+#📊  Function to interact with Salesforce based on mode and type
+def interact_with_salesforce(mode, entry_type, quantity, extracted_text):
     try:
         sf = Salesforce(
             username=SALESFORCE_USERNAME,
             password=SALESFORCE_PASSWORD,
-            security_token=SALESFORCE_SECURITY_TOKEN,
+            security_token=SALESFORCE_SECURITY_TOKEN
         )
 
-        object_name = "VENKATA_RAMANA_MOTORS__c"
-        sf_object = sf.__getattr__(object_name)
+        # Mapping mode and entry_type to Salesforce object and field
+        object_name = None
+        field_name = None
+        product_field_name = "Product_Name__c"  # Correct field for product name in the object
+        model_field_name = "Modal_Name__c"  # Correct field for model name in the object
 
+        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"
+        elif mode == "Exit":
+            if entry_type == "Sales":
+                object_name = "Inventory_Management__c"
+                product_field_name = "Product_Name__c"
+                model_field_name = "Modal_Name__c"
+                field_name = "Quantity_Sold__c"
+            elif entry_type == "Non-Sales":
+                object_name = "Un_Billable__c"
+                product_field_name = "Product_Name__c"
+                model_field_name = "Model_Name__c"
+                field_name = "Sold_Out__c"
+
+        if not object_name or not field_name:
+            return "Invalid mode or entry type."
+
+        # Get valid fields for the specified Salesforce object
+        sf_object = sf.__getattr__(object_name)
         schema = sf_object.describe()
         valid_fields = {field["name"] for field in schema["fields"]}
 
-        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}."
+        # Extract product name or model number
+        product_name = match_product_name(extracted_text)
+        attributes = extract_attributes(extracted_text)
+
+        if not product_name:
+            return "Product name could not be matched from the extracted text."
+
+        attributes["Product name"] = product_name
+
+        if mode == "Exit":
+            query = f"SELECT Id, {field_name} FROM {object_name} WHERE {product_field_name} = '{product_name}' OR {model_field_name} = '{attributes.get('Model Name', '')}' LIMIT 1"
+            response = sf.query(query)
+
+            if response["records"]:
+                record_id = response["records"][0]["Id"]
+                updated_quantity = quantity  # Overwrite the quantity, don't add
+                sf_object.update(record_id, {field_name: updated_quantity})
+                return f"Updated record for product '{product_name}' in {object_name}. New {field_name}: {updated_quantity}."
+            else:
+                return f"No matching record found for product '{product_name}' in {object_name}."
+        else:
+            filtered_attributes = filter_valid_attributes(attributes, valid_fields)
+            filtered_attributes[field_name] = quantity
+            sf_object.create(filtered_attributes)
+            return f"✅ Data successfully exported to Salesforce object {object_name}."
+
     except Exception as e:
-        return f"Error adding stock to VENKATA_RAMANA_MOTORS__c: {str(e)}"
+        return f"❌ Error interacting with Salesforce: {str(e)}"
 
-# Function to handle exit mode
-def subtract_stock_from_inventory(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,
+            security_token=SALESFORCE_SECURITY_TOKEN
         )
+        motor_data = sf.apexecute("MotorDataAPI/", method="GET")
+        return motor_data  # API returns the list of records
+    except Exception as e:
+        return f"Error pulling data from MotorDataAPI: {str(e)}"
 
-        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."
-
-        record_id = response["records"][0]["Id"]
-        current_quantity_sold = response["records"][0].get("Quantity_Sold__c", 0)
+# Function to format Salesforce data into a DataFrame with readable headers
+def format_salesforce_data():
+    try:
+        data = pull_data_from_motor_api()
+        if isinstance(data, list):
+            df = pd.DataFrame(data)
+            df = df.rename(columns={
+                "Product_Name__c": "Product Name",
+                "Modal_Name__c": "Model Name",
+                "Current_Stocks__c": "Current Stocks"
+            })
+            # Remove unnecessary columns
+            df = df[["Product Name", "Model Name", "Current Stocks"]]
+            return df
+        else:
+            return None
+    except Exception as e:
+        return None
 
-        # Update the quantity sold
-        updated_quantity_sold = current_quantity_sold + quantity
+# 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)
+        img = Image.open(buffer)
+        return img
+    except Exception as e:
+        return None
 
-        sf_object.update(record_id, {"Quantity_Sold__c": updated_quantity_sold})
+# Unified function to handle image processing and Salesforce interaction
+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 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)}"
+    product_name = match_product_name(extracted_text)
+    attributes = extract_attributes(extracted_text)
+    if product_name:
+        attributes["Product name"] = product_name
 
-# Unified function for processing
-def process_image(image, quantity, mode):
-    try:
-        extracted_text = extract_text(image)
-        attributes = find_attributes(extracted_text)
-        attributes["Quantity__c"] = sanitize_numeric(quantity)
+    # Interact with Salesforce
+    message = interact_with_salesforce(mode, entry_type, quantity, extracted_text)
 
-        if not attributes:
-            return "No attributes found in the image.", None
+    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
 
-        numbered_output = "\n".join(
-            [f"{key.replace('__c', '').replace('_', ' ').title()}: {value}" for key, value in attributes.items()]
-        )
 
-        file_path = save_to_excel(attributes)
+import gradio as gr
+import numpy as np
+from PIL import Image
+
+# Function to fetch and return Salesforce data
+def generate_salesforce_data():
+    df = format_salesforce_data()
+    if df is not None:
+        table_component = df.to_html(index=False)
+        bar_graph_image = generate_bar_graph(df)
+        return table_component, bar_graph_image
+    return "<p>No Data Available</p>", None
+
+def app():
+    with gr.Blocks(css="""
+        /* General Styling */
+        .gradio-container { 
+            background: #0b0f29; /* Deep Dark Blue */
+            font-family: 'Poppins', sans-serif;
+            color: white;
+            padding: 10px;
+        }
+
+        h1, h2, h3 {
+            text-align: center;
+            color: white;
+            font-weight: bold;
+            text-shadow: 0px 0px 10px rgba(255,255,255,0.8);
+        }
+
+        /* Cards & Elements */
+        .card {
+            background: rgba(255, 255, 255, 0.1);
+            border-radius: 15px;
+            padding: 20px;
+            width: 100%;
+            max-width: 900px; /* Prevents extra-wide tables */
+            margin: auto; /* Centers the table */
+            box-shadow: 0px 0px 25px rgba(0, 255, 255, 0.6);
+            transition: 0.3s;
+        }
+
+        .card:hover {
+            box-shadow: 0px 0px 30px rgba(0, 255, 255, 0.9);
+        }
+
+        /* Buttons */
+        .gradio-button {
+            background: linear-gradient(to right, #ff416c, #ff4b2b);
+            color: white !important;
+            border-radius: 10px !important;
+            font-weight: bold;
+            padding: 12px;
+            transition: all 0.3s ease-in-out;
+            box-shadow: 0px 0px 20px rgba(255, 0, 255, 0.6);
+        }
+
+        .gradio-button:hover {
+            background: linear-gradient(to right, #ff4b2b, #ff416c);
+            box-shadow: 0px 0px 30px rgba(255, 0, 255, 0.9);
+        }
+
+        /* Tabs */
+        .gradio-tab {
+            font-size: 16px;
+            color: white;
+            font-weight: bold;
+            text-shadow: 0px 0px 10px rgba(255, 255, 255, 0.6);
+        }
+
+        /* Scrollable Table */
+        .table-container {
+            width: 100%;
+            max-width: 900px;
+            max-height: 400px; /* Controls table height */
+            overflow-y: auto; /* Enables vertical scrolling */
+            overflow-x: auto; /* Enables horizontal scrolling if needed */
+            display: flex;
+            justify-content: center;
+            margin: auto;
+        }
+
+        table {
+            width: 100%;
+            border-collapse: collapse;
+            background: rgba(255, 255, 255, 0.1);
+            color: white;
+            min-width: 600px;
+        }
+
+        th, td {
+            padding: 12px;
+            text-align: left;
+            border-bottom: 1px solid rgba(255, 255, 255, 0.2);
+            font-size: 14px;
+        }
+
+        th {
+            background: rgba(0, 255, 255, 0.2);
+        }
+
+        /* Mobile View */
+        @media (max-width: 768px) {
+            .gradio-container {
+                padding: 10px;
+            }
+
+            .card {
+                width: 100%;
+                max-width: 100%;
+                padding: 10px;
+            }
+
+            .table-container {
+                max-height: 350px; /* Adjusts for mobile */
+                overflow-y: scroll; /* Ensures vertical scrolling */
+            }
+
+            table {
+                width: 100%;
+                min-width: 100%;
+            }
+
+            th, td {
+                font-size: 12px;
+                padding: 8px;
+            }
+        }
+
+    """) as interface:
+
+        gr.Markdown("<h1>🏢 VENKATARAMANA MOTORS</h1>")
+
+        with gr.Tab("📥 Stock Entry & Processing"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("<h3>📌 Upload & Process</h3>")
+                    image_input = gr.Image(type="numpy", label="📄 Upload Image", elem_classes="card")
+                    mode_dropdown = gr.Dropdown(label="📌 Mode", choices=["Entry", "Exit"], value="Entry", elem_classes="card")
+                    entry_type_radio = gr.Radio(label="📦 Entry Type", choices=["Sales", "Non-Sales"], value="Sales", elem_classes="card")
+                    quantity_input = gr.Number(label="🔢 Quantity", value=1, interactive=True, elem_classes="card")
+
+                with gr.Column():
+                    gr.Markdown("<h3>📊 Processed Data</h3>")
+                    image_view = gr.Text(label="📜 Image Data Viewer", interactive=False, elem_classes="card")
+                    result_output = gr.Text(label="📝 Processed Result", interactive=False, elem_classes="card")
+                    submit_button = gr.Button("🔍 Process Image", elem_id="process-btn", elem_classes="gradio-button")
+
+        with gr.Tab("📊 Salesforce Data Overview"):
+            gr.Markdown("<h3>📑 Stock Table</h3>")
+            with gr.Row(elem_classes="table-container"):
+                salesforce_table = gr.HTML(label="📦 Salesforce Data Table", elem_classes="card")
+
+            gr.Markdown("<h3>📈 Inventory Analytics</h3>")
+            with gr.Row():
+                salesforce_graph = gr.Image(type="pil", label="📉 Stock Distribution Bar Graph", elem_classes="card")
+
+            generate_button = gr.Button("⚡ Generate Data", elem_classes="gradio-button")
+
+        # Clicking "Generate Data" fetches table & graph
+        generate_button.click(fn=generate_salesforce_data, inputs=[], outputs=[salesforce_table, salesforce_graph])
+
+        submit_button.click(fn=process_image, inputs=[image_input, mode_dropdown, entry_type_radio, quantity_input], outputs=[image_view, result_output])
+
+        return interface
+
+interface = app()
+interface.launch()
+css = """
+    body {
+        background: linear-gradient(135deg, #282c34, #4b79a1);
+        font-family: 'Poppins', sans-serif;
+    }
+
+    .gradio-container {
+        border-radius: 20px;
+        padding: 30px;
+        background: rgba(255, 255, 255, 0.2);
+        backdrop-filter: blur(10px);
+        box-shadow: 0px 8px 30px rgba(0, 123, 255, 0.4);
+        border: 2px solid rgba(255, 255, 255, 0.4);
+    }
+
+    .gradio-title {
+        font-size: 48px;
+        font-weight: bold;
+        text-align: center;
+        background: linear-gradient(90deg, #ff7eb3, #ff758c);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        text-shadow: 5px 5px 20px rgba(255, 105, 180, 0.6);
+        margin-bottom: 20px;
+        animation: glow 2s infinite alternate;
+    }
+
+    @keyframes glow {
+        from {
+            text-shadow: 5px 5px 30px rgba(255, 87, 134, 0.6);
+        }
+        to {
+            text-shadow: 6px 6px 40px rgba(255, 54, 90, 1);
+        }
+    }
+
+    .gradio-box {
+        border-radius: 15px;
+        padding: 25px;
+        background: linear-gradient(135deg, #6a11cb, #2575fc);
+        box-shadow: 0px 6px 25px rgba(30, 144, 255, 0.6);
+        border: 2px solid #6a5acd;
+        color: white;
+        font-size: 18px;
+    }
+
+    .gradio-button {
+        border-radius: 12px;
+        padding: 18px 36px;
+        font-size: 20px;
+        font-weight: bold;
+        color: #fff;
+        background: linear-gradient(135deg, #1e90ff, #00bfff);
+        box-shadow: 0px 6px 25px rgba(0, 191, 255, 0.6);
+        transition: all 0.3s ease-in-out;
+    }
+
+    .gradio-button:hover {
+        background: linear-gradient(135deg, #00bfff, #1e90ff);
+        box-shadow: 0px 10px 35px rgba(0, 191, 255, 0.9);
+        transform: scale(1.1);
+    }
+
+    .gradio-input {
+        border-radius: 10px;
+        padding: 16px;
+        font-size: 18px;
+        background: rgba(255, 255, 255, 0.3);
+        border: 2px solid rgba(0, 123, 255, 0.5);
+        color: #fff;
+        transition: 0.3s;
+    }
+
+    .gradio-input:focus {
+        border: 2px solid #1e90ff;
+        outline: none;
+        box-shadow: 0px 5px 20px rgba(30, 144, 255, 0.6);
+    }
+
+    .gradio-output {
+        background: linear-gradient(135deg, #f39c12, #e74c3c);
+        padding: 22px;
+        border-radius: 15px;
+        color: white;
+        font-size: 20px;
+        text-align: center;
+        border: 2px solid #f39c12;
+    }
+
+    .gradio-file {
+        background: linear-gradient(135deg, #8e44ad, #3498db);
+        color: white;
+        padding: 16px;
+        border-radius: 15px;
+        text-align: center;
+        font-size: 18px;
+    }
+"""
 
-        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."
 
-        return f"{numbered_output}\n\n{message}", file_path
 
-    except Exception as e:
-        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 - VENKATA RAMANA MOTORS",
-    description="Process images for Entry or Exit mode to update stock.",
-)
 
 if __name__ == "__main__":
-    interface.launch(share=True)
+    app().launch(share=True)