Update app.py

app.py

@@ -7,9 +7,8 @@ import datetime
 import logging
 import sys
 from simple_salesforce import Salesforce
-from decouple import config
 
-# Configure logging
+# Configure logging to capture errors and debug information
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
@@ -20,14 +19,10 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Load Salesforce credentials from environment variables
-try:
-    SALESFORCE_USERNAME = config('SALESFORCE_USERNAME')
-    SALESFORCE_PASSWORD = config('SALESFORCE_PASSWORD')
-    SALESFORCE_SECURITY_TOKEN = config('SALESFORCE_SECURITY_TOKEN')
-except Exception as e:
-    logger.error(f"Failed to load environment variables: {str(e)}")
-    raise
+# Salesforce credentials
+SALESFORCE_USERNAME = "[email protected]"
+SALESFORCE_PASSWORD = "Vijaya@1888"
+SALESFORCE_SECURITY_TOKEN = "LfxlLZssa4Bp9vTSd0B78Cyu"
 
 # Initialize Salesforce connection
 try:
@@ -42,7 +37,7 @@ except Exception as e:
     logger.error(f"Failed to connect to Salesforce: {str(e)}")
     raise
 
-# Initialize PaddleOCR
+# Initialize PaddleOCR with error handling
 try:
     logger.info("Initializing PaddleOCR...")
     ocr = PaddleOCR(use_angle_cls=True, lang='en')
@@ -51,126 +46,146 @@ except Exception as e:
     logger.error(f"Failed to initialize PaddleOCR: {str(e)}")
     raise
 
+# Function to calculate materials based on blueprint dimensions (wall and foundation)
 def calculate_materials_from_dimensions(wall_area, foundation_area, structure_type):
     logger.info(f"Calculating materials for wall_area={wall_area:.2f} m², foundation_area={foundation_area:.2f} m²")
-    wall_materials = {
+    materials = {
         "cement": 0,
         "bricks": 0,
         "steel": 0,
         "sand": 0,
-        "gravel": 0
-    }
-    foundation_materials = {
-        "cement": 0,
-        "bricks": 0,
-        "steel": 0,
-        "sand": 0,
-        "gravel": 0
-    }
-
-    # Material coefficients based on structure type
-    coefficients = {
-        "Residential": {
-            "cement_wall": 10, "cement_foundation": 20,
-            "brick_wall": 500, "brick_foundation": 750,
-            "steel_wall": 2, "steel_foundation": 5,
-            "sand_wall": 0.5, "sand_foundation": 0.8,
-            "gravel_wall": 0.8, "gravel_foundation": 1.2
-        },
-        "Commercial": {
-            "cement_wall": 12, "cement_foundation": 25,
-            "brick_wall": 600, "brick_foundation": 900,
-            "steel_wall": 3, "steel_foundation": 7,
-            "sand_wall": 0.7, "sand_foundation": 1.0,
-            "gravel_wall": 1.0, "gravel_foundation": 1.5
-        },
-        "Industrial": {
-            "cement_wall": 15, "cement_foundation": 30,
-            "brick_wall": 700, "brick_foundation": 1000,
-            "steel_wall": 4, "steel_foundation": 8,
-            "sand_wall": 0.9, "sand_foundation": 1.2,
-            "gravel_wall": 1.2, "gravel_foundation": 1.8
-        }
+        "gravel": 0,
+        "tiles": 0
     }
 
-    coeffs = coefficients.get(structure_type, coefficients["Residential"])
-
-    # Wall calculations
+    # Adjust material coefficients based on structure type
+    if structure_type == "Residential":
+        cement_factor_wall = 10  # kg/m²
+        cement_factor_foundation = 20
+        brick_factor_wall = 500
+        brick_factor_foundation = 750
+        steel_factor_wall = 2
+        steel_factor_foundation = 5
+        sand_factor_wall = 0.5
+        sand_factor_foundation = 0.8
+        gravel_factor_wall = 0.8
+        gravel_factor_foundation = 1.2
+    elif structure_type == "Commercial":
+        cement_factor_wall = 12
+        cement_factor_foundation = 25
+        brick_factor_wall = 600
+        brick_factor_foundation = 900
+        steel_factor_wall = 3
+        steel_factor_foundation = 7
+        sand_factor_wall = 0.7
+        sand_factor_foundation = 1.0
+        gravel_factor_wall = 1.0
+        gravel_factor_foundation = 1.5
+    else:  # Industrial
+        cement_factor_wall = 15
+        cement_factor_foundation = 30
+        brick_factor_wall = 700
+        brick_factor_foundation = 1000
+        steel_factor_wall = 4
+        steel_factor_foundation = 8
+        sand_factor_wall = 0.9
+        sand_factor_foundation = 1.2
+        gravel_factor_wall = 1.2
+        gravel_factor_foundation = 1.8
+
+    # Wall calculations (in m²)
     if wall_area > 0:
-        wall_materials['cement'] = wall_area * coeffs['cement_wall']
-        wall_materials['bricks'] = wall_area * coeffs['brick_wall']
-        wall_materials['steel'] = wall_area * coeffs['steel_wall']
-        wall_materials['sand'] = wall_area * coeffs['sand_wall']
-        wall_materials['gravel'] = wall_area * coeffs['gravel_wall']
+        materials['cement'] += wall_area * cement_factor_wall
+        materials['bricks'] += wall_area * brick_factor_wall
+        materials['steel'] += wall_area * steel_factor_wall
+        materials['sand'] += wall_area * sand_factor_wall
+        materials['gravel'] += wall_area * gravel_factor_wall
 
-    # Foundation calculations
+    # Foundation calculations (in m²)
     if foundation_area > 0:
-        foundation_materials['cement'] = foundation_area * coeffs['cement_foundation']
-        foundation_materials['bricks'] = foundation_area * coeffs['brick_foundation']
-        foundation_materials['steel'] = foundation_area * coeffs['steel_foundation']
-        foundation_materials['sand'] = foundation_area * coeffs['sand_foundation']
-        foundation_materials['gravel'] = foundation_area * coeffs['gravel_foundation']
+        materials['cement'] += foundation_area * cement_factor_foundation
+        materials['bricks'] += foundation_area * brick_factor_foundation
+        materials['steel'] += foundation_area * steel_factor_foundation
+        materials['sand'] += foundation_area * sand_factor_foundation
+        materials['gravel'] += foundation_area * gravel_factor_foundation
 
-    logger.info(f"Wall materials: {wall_materials}")
-    logger.info(f"Foundation materials: {foundation_materials}")
-    return wall_materials, foundation_materials
+    logger.info(f"Blueprint materials calculated: {materials}")
+    return materials
 
+# Function to calculate materials based on site area, slab thickness, and wall height
 def calculate_construction_materials(site_area, slab_thickness, wall_height):
     logger.info(f"Calculating construction materials for site_area={site_area:.2f} sq ft, "
                 f"slab_thickness={slab_thickness:.2f} ft, wall_height={wall_height:.2f} ft")
-    slab_materials = {
-        "cement": 0,
-        "sand": 0,
-        "gravel": 0,
-        "steel": 0,
-        "bricks": 0
-    }
-    wall_materials = {
-        "cement": 0,
-        "sand": 0,
-        "gravel": 0,
-        "steel": 0,
-        "bricks": 0
-    }
-
-    # Concrete mix ratio (Cement:Sand:Gravel = 1:2:4)
-    cement_ratio, sand_ratio, gravel_ratio = 1, 2, 4
+    # Concrete Mix Ratio (Cement: Sand: Gravel)
+    cement_ratio = 1
+    sand_ratio = 2
+    gravel_ratio = 4
     total_ratio = cement_ratio + sand_ratio + gravel_ratio
+
+    # Steel estimation (kg per cubic foot of concrete)
     steel_per_cubic_ft = 1.5
-    brick_size = 0.10  # 7.5in × 3.5in ≈ 0.10 sq ft
 
+    # Brick size (in square feet per brick)
+    brick_size = 0.10  # 7.5 inches × 3.5 inches (approx 0.10 sq ft per brick)
+
+    # Tile size (in square feet per tile)
+    tile_size = 1  # 1x1 foot tiles
+
+    # Concrete Calculation
     try:
         slab_volume = site_area * slab_thickness
+        foundation_volume = site_area * slab_thickness * 3
+        total_concrete_volume = slab_volume + foundation_volume
     except Exception as e:
-        logger.error(f"Error calculating slab volume: {str(e)}")
+        logger.error(f"Error calculating concrete volume: {str(e)}")
         raise
 
-    # Slab calculations
-    slab_materials['cement'] = (cement_ratio / total_ratio) * slab_volume
-    slab_materials['sand'] = (sand_ratio / total_ratio) * slab_volume
-    slab_materials['gravel'] = (gravel_ratio / total_ratio) * slab_volume
-    slab_materials['steel'] = steel_per_cubic_ft * slab_volume
+    # Materials for Concrete Mix
+    cement_needed = (cement_ratio / total_ratio) * total_concrete_volume  # in cubic feet
+    sand_needed = (sand_ratio / total_ratio) * total_concrete_volume
+    gravel_needed = (gravel_ratio / total_ratio) * total_concrete_volume
+
+    # Steel Bars Calculation
+    steel_needed = steel_per_cubic_ft * total_concrete_volume
 
-    # Wall calculations (from construction perspective)
-    wall_materials['bricks'] = (wall_height * site_area) / brick_size
+    # Bricks Calculation
+    bricks_needed = (wall_height * site_area) / brick_size
 
-    logger.info(f"Slab materials: {slab_materials}")
-    logger.info(f"Construction wall materials: {wall_materials}")
-    return slab_materials, wall_materials
+    # Tiles Calculation
+    tiles_needed = site_area / tile_size
 
+    materials = {
+        'cement': cement_needed,  # in cubic feet (will convert to kg for Salesforce)
+        'sand': sand_needed,
+        'gravel': gravel_needed,
+        'steel': steel_needed,
+        'bricks': bricks_needed,
+        'tiles': tiles_needed
+    }
+    logger.info(f"Construction materials calculated: {materials}")
+    return materials
+
+# Function to process the blueprint and extract dimensions
 def process_blueprint(image, blueprint_title, uploaded_by, structure_type, site_area, slab_thickness, wall_height):
     logger.info("Processing blueprint image...")
     try:
+        # Convert PIL image to OpenCV format
         open_cv_image = np.array(image)
         open_cv_image = cv2.cvtColor(open_cv_image, cv2.COLOR_RGB2BGR)
     except Exception as e:
         logger.error(f"Error converting image to OpenCV format: {str(e)}")
         raise
 
+    # Convert to grayscale for easier processing
     gray = cv2.cvtColor(open_cv_image, cv2.COLOR_BGR2GRAY)
+
+    # Apply edge detection to find lines (walls)
     edges = cv2.Canny(gray, 50, 150, apertureSize=3)
+
+    # Use Hough Transform to detect lines (walls)
     lines = cv2.HoughLinesP(edges, 1, np.pi / 180, threshold=100, minLineLength=50, maxLineGap=10)
 
+    # Calculate total wall length (in pixels)
     total_wall_length_pixels = 0
     if lines is not None:
         for line in lines:
@@ -179,165 +194,143 @@ def process_blueprint(image, blueprint_title, uploaded_by, structure_type, site_
             total_wall_length_pixels += length
     logger.info(f"Total wall length (pixels): {total_wall_length_pixels:.2f}")
 
+    # From the blueprint, we know the dimensions (27 m × 9.78 m)
     image_height, image_width = open_cv_image.shape[:2]
-    blueprint_width_m = 27  # Fixed blueprint dimensions
-    blueprint_height_m = 9.78
-    pixel_to_meter = ((blueprint_width_m / image_width) + (blueprint_height_m / image_height)) / 2
+    blueprint_width_m = 27  # From the blueprint (27 m)
+    blueprint_height_m = 9.78  # From the blueprint (9.78 m)
+
+    # Calculate pixel-to-meter ratio
+    pixel_to_meter_width = blueprint_width_m / image_width
+    pixel_to_meter_height = blueprint_height_m / image_height
+    pixel_to_meter = (pixel_to_meter_width + pixel_to_meter_height) / 2
     logger.info(f"Pixel-to-meter ratio: {pixel_to_meter:.6f}")
 
+    # Convert wall length to meters
     total_wall_length_m = total_wall_length_pixels * pixel_to_meter
-    wall_area = total_wall_length_m * 3  # Assume 3m wall height
-    total_area = blueprint_width_m * blueprint_height_m
-    foundation_area = total_area * 0.1
-    logger.info(f"Wall area: {wall_area:.2f} m², Foundation area: {foundation_area:.2f} m²")
+    logger.info(f"Total wall length (meters): {total_wall_length_m:.2f}")
 
-    # Calculate materials
-    blueprint_wall_materials, foundation_materials = calculate_materials_from_dimensions(wall_area, foundation_area, structure_type)
-    slab_materials, construction_wall_materials = calculate_construction_materials(site_area, slab_thickness, wall_height)
+    # Estimate wall area (assume wall height of 3 m for simplicity)
+    wall_height_m = 3  # Standard room height
+    wall_area = total_wall_length_m * wall_height_m
+    logger.info(f"Wall area: {wall_area:.2f} m²")
 
-    cement_conversion_factor = 144  # kg per cubic foot
-    combined_wall_materials = {
-        'cement': blueprint_wall_materials['cement'] + (construction_wall_materials['cement'] * cement_conversion_factor),
-        'sand': blueprint_wall_materials['sand'] + construction_wall_materials['sand'],
-        'gravel': blueprint_wall_materials['gravel'] + construction_wall_materials['gravel'],
-        'steel': blueprint_wall_materials['steel'] + construction_wall_materials['steel'],
-        'bricks': blueprint_wall_materials['bricks'] + construction_wall_materials['bricks']
-    }
-    combined_slab_materials = {
-        'cement': slab_materials['cement'] * cement_conversion_factor,
-        'sand': slab_materials['sand'],
-        'gravel': slab_materials['gravel'],
-        'steel': slab_materials['steel'],
-        'bricks': slab_materials['bricks']
-    }
+    # Estimate foundation area (based on the blueprint's total area)
+    total_area = blueprint_width_m * blueprint_height_m  # 27 m × 9.78 m
+    foundation_area = total_area * 0.1  # Assume 10% of the total area is foundation
+    logger.info(f"Foundation area: {foundation_area:.2f} m²")
+
+    # Calculate materials based on blueprint dimensions
+    blueprint_materials = calculate_materials_from_dimensions(wall_area, foundation_area, structure_type)
 
-    logger.info(f"Combined wall materials: {combined_wall_materials}")
-    logger.info(f"Combined slab materials: {combined_slab_materials}")
-
-    # Generate Quantity JSON
-    quantity_json = {
-        "blueprint_id": blueprint_title,
-        "structural_elements": [
-            {
-                "element_type": "wall",
-                "dimensions": {"length_m": total_wall_length_m, "height_m": 3.0, "area_m2": wall_area},
-                "material_quantities": {
-                    "cement_kg": combined_wall_materials['cement'],
-                    "bricks_units": combined_wall_materials['bricks'],
-                    "steel_kg": combined_wall_materials['steel'],
-                    "sand_cft": combined_wall_materials['sand'],
-                    "gravel_cft": combined_wall_materials['gravel']
-                }
-            },
-            {
-                "element_type": "slab",
-                "dimensions": {"area_sqft": site_area, "thickness_ft": slab_thickness},
-                "material_quantities": {
-                    "cement_kg": combined_slab_materials['cement'],
-                    "bricks_units": combined_slab_materials['bricks'],
-                    "steel_kg": combined_slab_materials['steel'],
-                    "sand_cft": combined_slab_materials['sand'],
-                    "gravel_cft": combined_slab_materials['gravel']
-                }
-            },
-            {
-                "element_type": "foundation",
-                "dimensions": {"area_m2": foundation_area},
-                "material_quantities": {
-                    "cement_kg": foundation_materials['cement'],
-                    "bricks_units": foundation_materials['bricks'],
-                    "steel_kg": foundation_materials['steel'],
-                    "sand_cft": foundation_materials['sand'],
-                    "gravel_cft": foundation_materials['gravel']
-                }
-            }
-        ],
-        "total_quantities": {
-            "cement_kg": combined_wall_materials['cement'] + combined_slab_materials['cement'] + foundation_materials['cement'],
-            "bricks_units": combined_wall_materials['bricks'] + combined_slab_materials['bricks'] + foundation_materials['bricks'],
-            "steel_kg": combined_wall_materials['steel'] + combined_slab_materials['steel'] + foundation_materials['steel'],
-            "sand_cft": combined_wall_materials['sand'] + combined_slab_materials['sand'] + foundation_materials['sand'],
-            "gravel_cft": combined_wall_materials['gravel'] + combined_slab_materials['gravel'] + foundation_materials['gravel']
-        },
-        "estimation_accuracy": {"score": 0.95, "warnings": []}
+    # Calculate construction materials based on site area, slab thickness, and wall height
+    construction_materials = calculate_construction_materials(site_area, slab_thickness, wall_height)
+
+    # Combine materials from both calculations
+    # Convert cement from cubic feet to kg for Salesforce (1 cubic foot ≈ 144 kg for cement)
+    cement_conversion_factor = 144  # kg per cubic foot
+    combined_materials = {
+        'cement': (blueprint_materials['cement'] + (construction_materials['cement'] * cement_conversion_factor)),  # in kg
+        'sand': blueprint_materials['sand'] + construction_materials['sand'],  # in CFT
+        'gravel': blueprint_materials['gravel'] + construction_materials['gravel'],  # in CFT
+        'steel': blueprint_materials['steel'] + construction_materials['steel'],  # in kg
+        'bricks': blueprint_materials['bricks'] + construction_materials['bricks'],  # units
+        'tiles': construction_materials['tiles']  # units
     }
+    logger.info(f"Combined materials: {combined_materials}")
 
+    # Generate Material_Summary__c in HTML format (for display)
     material_summary = f"""
-    <h3>Wall Material Requirements:</h3>
-    <p><b>Cement:</b> {combined_wall_materials['cement']:.2f} kg</p>
-    <p><b>Sand:</b> {combined_wall_materials['sand']:.2f} CFT</p>
-    <p><b>Gravel:</b> {combined_wall_materials['gravel']:.2f} CFT</p>
-    <p><b>Steel:</b> {combined_wall_materials['steel']:.2f} kg</p>
-    <p><b>Bricks:</b> {combined_wall_materials['bricks']:.0f} units</p>
-    <h3>Slab Material Requirements:</h3>
-    <p><b>Cement:</b> {combined_slab_materials['cement']:.2f} kg</p>
-    <p><b>Sand:</b> {combined_slab_materials['sand']:.2f} CFT</p>
-    <p><b>Gravel:</b> {combined_slab_materials['gravel']:.2f} CFT</p>
-    <p><b>Steel:</b> {combined_slab_materials['steel']:.2f} kg</p>
-    <p><b>Bricks:</b> {combined_slab_materials['bricks']:.0f} units</p>
+    <h3>Construction Material Requirements:</h3>
+    <p><b>Cement:</b> {combined_materials['cement']:.2f} kg</p>
+    <p><b>Sand:</b> {combined_materials['sand']:.2f} CFT</p>
+    <p><b>Gravel:</b> {combined_materials['gravel']:.2f} CFT</p>
+    <p><b>Steel:</b> {combined_materials['steel']:.2f} kg</p>
+    <p><b>Bricks:</b> {combined_materials['bricks']:.0f} units</p>
+    <p><b>Tiles:</b> {combined_materials['tiles']:.0f} units</p>
     """
 
+    # Simulate Estimation_PDF__c as a placeholder URL
     estimation_pdf_url = "https://example.com/estimation_pdfs/blueprint_123.pdf"
+
+    # Current date for Upload_Date__c
     upload_date = datetime.datetime.now().strftime("%Y-%m-%d")
+
+    # Extract text from the image using PaddleOCR
     extracted_text = extract_text_with_paddleocr(image)
 
+    # Map fields to Salesforce record for Blue_print_Estimation__c
     salesforce_record = {
         "Blueprint_Title__c": blueprint_title,
-        "Uploaded_By__c": uploaded_by,
+        "Uploaded_By__c": uploaded_by,  # Assumes a valid User ID
         "Upload_Date__c": upload_date,
         "Structure_Type__c": structure_type,
-        "Cement_Required_KG__c": combined_wall_materials['cement'] + combined_slab_materials['cement'] + foundation_materials['cement'],
-        "Steel_Required_KG__c": combined_wall_materials['steel'] + combined_slab_materials['steel'] + foundation_materials['steel'],
-        "Brick_Count__c": combined_wall_materials['bricks'] + combined_slab_materials['bricks'] + foundation_materials['bricks'],
-        "Sand_Required_CFT__c": combined_wall_materials['sand'] + combined_slab_materials['sand'] + foundation_materials['sand'],
-        "Material_Summary__c": material_summary,
-        "Estimation_PDF__c": estimation_pdf_url,
-        "Gravel__c": combined_wall_materials['gravel'] + combined_slab_materials['gravel'] + foundation_materials['gravel']
+        "Cement_Required_KG__c": combined_materials['cement'],  # Already in kg
+        "Steel_Required_KG__c": combined_materials['steel'],  # Already in kg
+        "Brick_Count__c": combined_materials['bricks'],  # Units
+        "Sand__c": combined_materials['sand'],  # CFT
+        "Sand_Required_CFT__c": combined_materials['sand'],  # CFT (same as Sand__c)
+        "Material_Summary__c": material_summary,  # HTML formatted
+        "Estimation_PDF__c": estimation_pdf_url,  # URL
+        "Gravel__c": combined_materials['gravel'],  # CFT
+        "Tiles__c": combined_materials['tiles']  # Units
+        # Note: User__c is not mapped as it's assumed to be the same as Uploaded_By__c
     }
+    logger.info(f"Salesforce record prepared: {salesforce_record}")
 
+    # Create the record in Salesforce (using Blue_print_Estimation__c)
     try:
-        response = sf.Blueprint_Estimation__c.create(salesforce_record)
-        logger.info(f"Salesforce record created: {response}")
-        salesforce_record['Salesforce_Record_Id'] = response['id']
+        response = sf.Blue_print_Estimation__c.create(salesforce_record)
+        logger.info(f"Salesforce record created successfully: {response}")
+        salesforce_record['Salesforce_Record_Id'] = response['id']  # Add the record ID to the result
     except Exception as e:
         logger.error(f"Failed to create Salesforce record: {str(e)}")
         salesforce_record['Salesforce_Error'] = str(e)
 
-    result = {
-        "salesforce_record": salesforce_record,
-        "quantity_json": quantity_json,
-        "wall_materials": combined_wall_materials,
-        "slab_materials": combined_slab_materials
-    }
+    # Populate the fields in a structured dictionary for return
+    result = salesforce_record
+    logger.info("Blueprint processing completed successfully.")
     return result, extracted_text
 
+# Function to extract text using PaddleOCR
 def extract_text_with_paddleocr(image):
     logger.info("Extracting text with PaddleOCR...")
     try:
+        # Convert PIL image to OpenCV format
         open_cv_image = np.array(image)
         open_cv_image = cv2.cvtColor(open_cv_image, cv2.COLOR_RGB2BGR)
+
+        # Perform OCR using PaddleOCR
         ocr_results = ocr.ocr(open_cv_image, cls=True)
-        extracted_text = '\n'.join([line[1][0] for line in ocr_results[0]]) if ocr_results and ocr_results[0] else "No text detected."
-        logger.info("Text extracted successfully.")
+        if ocr_results and ocr_results[0]:
+            extracted_text = '\n'.join([line[1][0] for line in ocr_results[0]])
+            logger.info("Text extracted successfully.")
+        else:
+            extracted_text = "No text detected."
+            logger.info("No text detected in the image.")
         return extracted_text
     except Exception as e:
         logger.error(f"Error during OCR processing: {str(e)}")
         return f"OCR failed: {str(e)}"
 
+# Wrapper function for Gradio to handle image input and additional fields
 def gradio_process_file(image, blueprint_title, uploaded_by, structure_type, site_area, slab_thickness, wall_height):
     logger.info("Starting Gradio process...")
-    if not image:
+    if image is None:
         logger.error("No image uploaded.")
         return {"error": "No image uploaded"}, None
 
+    # Provide default values and validate numerical inputs
     try:
-        site_area = float(site_area or 1000.0)
-        slab_thickness = float(slab_thickness or 0.5)
-        wall_height = float(wall_height or 10.0)
+        # Check for None and provide defaults
+        site_area = float(site_area) if site_area is not None else 1000.0
+        slab_thickness = float(slab_thickness) if slab_thickness is not None else 0.5
+        wall_height = float(wall_height) if wall_height is not None else 10.0
+
+        logger.info(f"Input values - site_area: {site_area}, slab_thickness: {slab_thickness}, wall_height: {wall_height}")
+
+        # Validate that values are positive
         if site_area <= 0 or slab_thickness <= 0 or wall_height <= 0:
-            raise ValueError("Site area, slab thickness, and wall height must be positive.")
-        if not blueprint_title or not uploaded_by:
-            raise ValueError("Blueprint title and uploaded by fields are required.")
+            raise ValueError("Site area, slab thickness, and wall height must be positive numbers.")
     except (ValueError, TypeError) as e:
         logger.error(f"Invalid input: {str(e)}")
         return {"error": f"Invalid input: {str(e)}"}, None
@@ -350,13 +343,18 @@ def gradio_process_file(image, blueprint_title, uploaded_by, structure_type, sit
         logger.error(f"Gradio processing failed: {str(e)}")
         return {"error": str(e)}, None
 
+# Set up a single Gradio interface for image input with additional fields
 interface = gr.Interface(
     fn=gradio_process_file,
     inputs=[
         gr.Image(type="pil", label="Upload Blueprint Image"),
-        gr.Textbox(label="Blueprint Title", placeholder="Enter blueprint title"),
-        gr.Textbox(label="Uploaded By (Salesforce User ID)", placeholder="Enter Salesforce User ID"),
-        gr.Dropdown(choices=["Residential", "Commercial", "Industrial"], label="Structure Type", value="Residential"),
+        gr.Textbox(label="Blueprint Title", placeholder="Enter the blueprint title"),
+        gr.Textbox(label="Uploaded By (Salesforce User ID)", placeholder="Enter the Salesforce User ID (e.g., 005xxxxxxxxxxxx)"),
+        gr.Dropdown(
+            choices=["Residential", "Commercial", "Industrial"],
+            label="Structure Type",
+            value="Residential"
+        ),
         gr.Number(label="Site Area (sq ft)", value=1000.0, minimum=1.0),
         gr.Number(label="Slab Thickness (ft)", value=0.5, minimum=0.1),
         gr.Number(label="Wall Height (ft)", value=10.0, minimum=1.0)
@@ -366,9 +364,10 @@ interface = gr.Interface(
         gr.Textbox(label="Extracted Text")
     ],
     title="Blueprint Material Estimator",
-    description="Upload a blueprint to estimate materials and save to Salesforce."
+    description="Upload a blueprint image to estimate construction materials and save to Salesforce (Blue_print_Estimation__c)."
 )
 
+# Launch the interface
 if __name__ == "__main__":
     logger.info("Launching Gradio interface...")
     try:
@@ -376,4 +375,4 @@ if __name__ == "__main__":
         logger.info("Gradio interface launched successfully.")
     except Exception as e:
         logger.error(f"Failed to launch Gradio interface: {str(e)}")
-        sys.exit(1)
+        sys.exit(1)