quick

app.py

@@ -1,19 +1,20 @@
 # app.py
 import gradio as gr
 import logging # Import logging
-import sys # Import sys to output to stderr
+import sys # Import sys
 # Removed imports: pandas, openpyxl, datetime, timedelta, os, tempfile
 
 # Import the processing function from main.py
 from main import process_files
 
-# --- Configure Logging --- (Configure before functions)
-log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-logging.basicConfig(level=logging.INFO, # Use INFO for general info, DEBUG for more detail
-                    format=log_format,
-                    handlers=[logging.StreamHandler(sys.stderr)]) # Output to stderr
-
-logger = logging.getLogger(__name__) # Get logger for this module
+# Configure logging (consistent with main.py)
+# Note: If main.py is imported, its basicConfig might already run.
+# Re-configuring here ensures app.py specific logs also follow the format.
+# Using getLogger and adding handler might be more robust in complex scenarios,
+# but basicConfig is often sufficient for simpler apps.
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
+                    stream=sys.stderr)
 
 def generate_report(file1_obj, file2_obj):
     """
@@ -28,40 +29,40 @@ def generate_report(file1_obj, file2_obj):
     Raises:
         gr.Error: If file processing fails.
     """
-    logger.info("generate_report function called.")
+    logging.info("generate_report function called by Gradio.")
     if file1_obj is None or file2_obj is None:
-        logger.error("Missing one or both input files.")
+        logging.error("One or both files were not provided.")
         raise gr.Error("Please upload both required files.")
 
     try:
         # Gradio provides temporary paths for uploaded files
         file1_path = file1_obj.name
         file2_path = file2_obj.name
-        logger.info(f"Input file 1 path: {file1_path}")
-        logger.info(f"Input file 2 path: {file2_path}")
+        logging.info(f"Input file paths received: file1='{file1_path}', file2='{file2_path}'")
 
-        # Define the output filename
+        # Define the output filename (can be customized if needed)
         output_filename = "generated_report.xlsx"
-        logger.info(f"Target output base filename: {output_filename}")
+        logging.info(f"Target output base filename: {output_filename}")
 
         # Call the core processing logic from main.py
-        logger.info(f"Calling process_files...")
+        logging.info(f"Calling main.process_files...")
         result_path = process_files(file1_path, file2_path, output_filename)
-        logger.info(f"process_files returned: {result_path}")
+        logging.info(f"main.process_files returned: '{result_path}'")
 
         if result_path:
-            logger.info(f"Report generation successful. Returning path: {result_path}")
             # Return the path of the generated file for Gradio to serve
+            logging.info(f"Report generation successful. Returning path: {result_path}")
             return result_path
         else:
-            # If process_files returned None, it means an error occurred
-            logger.error("process_files returned None, indicating failure.")
+            # If process_files returned None, it means an error occurred (already logged in main.py)
+            logging.error("main.process_files indicated failure (returned None).")
             raise gr.Error("Failed to generate the report. Check application logs for details.")
 
     except Exception as e:
         # Catch any other unexpected errors during the wrapper execution
-        logger.exception("An unexpected error occurred in the Gradio wrapper (generate_report)") # Logs exception info automatically
-        raise gr.Error(f"An unexpected error occurred. Check application logs for details.") # User-friendly message
+        # Log the exception with traceback before raising Gradio error
+        logging.exception(f"An unexpected error occurred in the Gradio wrapper (generate_report): {e}")
+        raise gr.Error(f"An unexpected error occurred. Check application logs.")
 
 
 # Create Gradio Interface
@@ -87,5 +88,10 @@ demo = gr.Interface(
 )
 
 if __name__ == "__main__":
+    # Setup logging for direct script execution as well
+    logging.basicConfig(level=logging.INFO,
+                        format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
+                        stream=sys.stderr)
+    logging.info("Starting Gradio application...")
     # Launch the Gradio app
     demo.launch(server_name="0.0.0.0") # Port defaults to 7860 

main.py

@@ -4,9 +4,12 @@ from datetime import datetime, timedelta
 import os # Added for path manipulation
 import tempfile # Import tempfile
 import logging # Import logging
+import sys # Import sys to target stderr
 
-# Get logger for this module
-logger = logging.getLogger(__name__)
+# Configure logging
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
+                    stream=sys.stderr) # Log to stderr, usually captured by platforms
 
 def process_files(file1_path, file2_path, output_filename="generated_report.xlsx"):
     """
@@ -23,34 +26,33 @@ def process_files(file1_path, file2_path, output_filename="generated_report.xlsx
         str: The full path to the generated output Excel file in a temporary directory.
              Returns None if an error occurs during processing.
     """
-    logger.info(f"Starting report generation with input files: {file1_path}, {file2_path}")
+    logging.info(f"Starting report generation. Input 1: {file1_path}, Input 2: {file2_path}")
     try:
         # 读取第一个文件
-        logger.info(f"Reading header from {file1_path}")
+        logging.info(f"Reading header from: {file1_path}")
         header_df = pd.read_excel(file1_path, sheet_name='HEADER')
-        logger.info(f"Reading dimension data from {file1_path}")
+        logging.info(f"Reading dimension data from: {file1_path}")
         dimension_df = pd.read_excel(file1_path, sheet_name='Dimension', skiprows=12)
         dimension_df.columns = dimension_df.iloc[0]
         dimension_df = dimension_df.iloc[1:].reset_index(drop=True)
-        logger.info(f"Reading sand data from {file1_path}")
+        logging.info(f"Reading sand data from: {file1_path}")
         sand_df = pd.read_excel(file1_path, sheet_name='Sand', header=None)
-        logger.info(f"Finished reading data from {file1_path}")
 
         # 读取第二个文件
-        logger.info(f"Loading template workbook from {file2_path}")
+        logging.info(f"Loading template workbook: {file2_path}")
         wb = load_workbook(file2_path)
         
         # Check if 'WACKER' sheet exists
         if 'WACKER' not in wb.sheetnames:
-            logger.error(f"Template file '{file2_path}' must contain a sheet named 'WACKER'.")
+            logging.error("Error: Template file must contain a sheet named 'WACKER'.")
             return None # Indicate error
         wacker_sheet = wb['WACKER']
-        logger.info("Template workbook loaded successfully.")
+        logging.info("Template sheet 'WACKER' found.")
 
         # 获取Sales Order Quantity和Quality Assured By
         sales_order_quantity = header_df.iloc[5, 2]
         quality_assured_by = header_df.iloc[3, 7]
-        logger.info(f"Retrieved Sales Order Qty: {sales_order_quantity}, Quality Assured By: {quality_assured_by}")
+        logging.info(f"Extracted Sales Order Qty: {sales_order_quantity}, Assured By: {quality_assured_by}")
 
         # 定义元素和行号的对应关系 (Copied from original script)
         element_row_mapping = {
@@ -62,7 +64,7 @@ def process_files(file1_path, file2_path, output_filename="generated_report.xlsx
             'Mg': 10, 'Mn': 11, 'Na': 12, 'Ti': 13, 'Zr': 14
         }
 
-        logger.info(f"Processing {len(dimension_df)} entries from dimension data.")
+        logging.info("Starting iteration through dimension data.")
         # 遍历Dimension表格中的每个Customer ID
         for index, row in dimension_df.iterrows():
             customer_id = row['Customer ID']
@@ -72,10 +74,10 @@ def process_files(file1_path, file2_path, output_filename="generated_report.xlsx
 
             # Handle potential NaN or empty Customer ID
             if pd.isna(customer_id) or not str(customer_id).strip():
-                logger.warning(f"Skipping row {index+14} due to missing or invalid Customer ID.")
+                logging.warning(f"Skipping row {index+14} due to missing or invalid Customer ID.")
                 continue
-
-            logger.debug(f"Processing Customer ID: {customer_id} (Index: {index})") # Use debug for per-item processing
+            
+            logging.debug(f"Processing Customer ID: {customer_id} (Sheet Name: {safe_customer_id})") # Debug level for per-row info
 
             inspection_date_str = ""
             inspection_date = None # Initialize inspection_date
@@ -86,10 +88,12 @@ def process_files(file1_path, file2_path, output_filename="generated_report.xlsx
                 else:
                     inspection_date = pd.to_datetime(row['Inspection Date'])
                 inspection_date_str = inspection_date.strftime('%Y-%m-%d')
-            except Exception as e:
-                logger.warning(f"Could not parse Inspection Date for Customer ID {customer_id}: {e}. Skipping date fields.")
+                logging.debug(f"Parsed Inspection Date for {customer_id}: {inspection_date_str}")
+            except Exception as date_parse_e:
+                logging.warning(f"Could not parse Inspection Date for Customer ID {customer_id}: {date_parse_e}. Skipping date fields.")
                 # inspection_date remains None
 
+
             new_sheet_title = safe_customer_id
             # Avoid duplicate sheet names if safe_customer_id becomes the same for different original IDs
             sheet_count = 1
@@ -98,7 +102,8 @@ def process_files(file1_path, file2_path, output_filename="generated_report.xlsx
                  max_len = 31 - len(suffix)
                  new_sheet_title = safe_customer_id[:max_len] + suffix
                  sheet_count += 1
-
+            
+            logging.debug(f"Creating new sheet with title: {new_sheet_title}")
             new_sheet = wb.create_sheet(title=new_sheet_title)
 
             # 复制WACKER表格的内容到新工作表
@@ -106,6 +111,7 @@ def process_files(file1_path, file2_path, output_filename="generated_report.xlsx
                 new_sheet.append(row_wacker)
 
             # 填充数据
+            logging.debug(f"Populating sheet {new_sheet_title} with data for {customer_id}")
             new_sheet['B3'] = str(sales_order_quantity) + ' PCS'
             new_sheet['B4'] = customer_id # Use original ID here
             if inspection_date: # Only fill dates if parsing was successful
@@ -113,6 +119,7 @@ def process_files(file1_path, file2_path, output_filename="generated_report.xlsx
                  new_sheet['B5'] = inspection_date_str
                  new_sheet['D5'] = (inspection_date + timedelta(days=730)).strftime('%Y-%m-%d')
 
+
             # 从sand表中获取当前customer_id的数据
             sand_rows = sand_df[sand_df[2] == customer_id] # 使用第3列（索引2）作为Crucible ID
             if not sand_rows.empty:
@@ -126,13 +133,15 @@ def process_files(file1_path, file2_path, output_filename="generated_report.xlsx
                         if value is not None and not pd.isna(value):
                              new_sheet[f'D{target_row}'] = value
                         else:
-                             logger.warning(f"Missing or invalid sand data for {element}, Customer ID {customer_id}, Col Index {source_col}")
+                             logging.warning(f"Missing or invalid sand data for {element}, Customer ID {customer_id}, Col Index {source_col}")
                              # Optionally fill with a default value or leave blank
                              # new_sheet[f'D{target_row}'] = "N/A"
                     except KeyError:
-                         logger.warning(f"Column index {source_col} not found in sand_row for {element}, Customer ID {customer_id}")
-                    except Exception as e:
-                         logger.error(f"Error filling element {element} for Customer ID {customer_id}: {e}")
+                         logging.warning(f"Column index {source_col} not found in sand_row for {element}, Customer ID {customer_id}")
+                    except Exception as elem_fill_e:
+                         # Log error but continue processing other elements/rows
+                         logging.error(f"Error filling element {element} for Customer ID {customer_id}: {elem_fill_e}")
+
 
             # 填充Analysis result/分析结果 (with added error handling)
             dim_mapping = {
@@ -147,21 +156,23 @@ def process_files(file1_path, file2_path, output_filename="generated_report.xlsx
                      if value is not None and not pd.isna(value):
                           new_sheet[f'D{target_row}'] = value
                      else:
-                         logger.warning(f"Missing or invalid dimension data for {source_col_name}, Customer ID {customer_id}")
+                         logging.warning(f"Missing or invalid dimension data for {source_col_name}, Customer ID {customer_id}")
                          # Optionally fill with a default value or leave blank
                          # new_sheet[f'D{target_row}'] = "N/A"
                  except KeyError:
-                     logger.warning(f"Column '{source_col_name}' not found in dimension_df for Customer ID {customer_id}")
-                 except Exception as e:
-                     logger.error(f"Error filling dimension {source_col_name} for Customer ID {customer_id}: {e}")
+                     logging.warning(f"Column '{source_col_name}' not found in dimension_df for Customer ID {customer_id}")
+                 except Exception as dim_fill_e:
+                     # Log error but continue processing other dimensions/rows
+                     logging.error(f"Error filling dimension {source_col_name} for Customer ID {customer_id}: {dim_fill_e}")
 
             # 保持"批准人："文本，并在其后添加名字
             new_sheet['D29'] = f"批准人：{quality_assured_by}"
-            logger.debug(f"Finished processing data for Customer ID: {customer_id}") # Use debug
+            logging.debug(f"Finished populating sheet for Customer ID: {customer_id}")
 
+        logging.info("Finished iterating through dimension data.")
         # Remove the original template sheet if it exists and wasn't intended to be kept
         if 'WACKER' in wb.sheetnames:
-             logger.info("Removing 'WACKER' template sheet from the output workbook.")
+             logging.info("Removing original 'WACKER' template sheet.")
              del wb['WACKER'] # Remove template if no longer needed
 
         # Create a temporary file path for the output
@@ -170,52 +181,46 @@ def process_files(file1_path, file2_path, output_filename="generated_report.xlsx
             # Ensure the base output filename is used, not a potentially problematic one from input args
             safe_output_filename = os.path.basename(output_filename if output_filename else "generated_report.xlsx")
             # Create a unique temporary file path
-            # Using mkstemp gives more control, but let's try simple join first
-            # _, temp_output_path = tempfile.mkstemp(suffix=".xlsx", prefix="report_", dir=temp_dir)
-            # Let's use a predictable name within the temp dir, might be easier for Gradio/platform
             temp_output_path = os.path.join(temp_dir, safe_output_filename)
             
-            logger.info(f"Attempting to save report to temporary path: {temp_output_path}")
+            logging.info(f"Attempting to save report to temporary path: {temp_output_path}")
             wb.save(temp_output_path)
-            logger.info(f"Successfully saved report to: {temp_output_path}")
+            logging.info(f"Successfully saved report to: {temp_output_path}")
             return temp_output_path # Return the full path to the temporary file
         except Exception as save_error:
-            logger.exception(f"Error saving workbook to temporary path {temp_output_path}") # Log exception
+            # Log the exception with traceback
+            logging.exception(f"Error saving workbook to temporary path {temp_output_path}: {save_error}")
             return None
 
-    except FileNotFoundError:
-        logger.error(f"Error: Input file not found. Check paths: {file1_path}, {file2_path}")
+    except FileNotFoundError as fnf_error:
+        logging.exception(f"Error: Input file not found. Check paths: {file1_path}, {file2_path}. Error: {fnf_error}")
         return None
-    except KeyError as e:
-        logger.exception(f"Error: Missing expected column or sheet name: {e}. Check input file formats.")
+    except KeyError as key_error:
+        logging.exception(f"Error: Missing expected column or sheet name: {key_error}. Check input file formats.")
         return None
-    except Exception as e:
-        # Log other unexpected errors
-        logger.exception(f"An unexpected error occurred in process_files: {e}")
+    except Exception as general_error:
+        # Log other unexpected errors with traceback
+        logging.exception(f"An unexpected error occurred in process_files: {general_error}")
         return None
 
 
 # Keep the original script behavior if run directly (optional)
 if __name__ == "__main__":
-    # Configure basic logging for direct script execution if needed
-    # Note: app.py usually handles the main config when run via Gradio
-    if not logging.getLogger().hasHandlers(): # Only configure if not already configured by app.py import
-        log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        logging.basicConfig(level=logging.INFO, format=log_format)
+    # Setup logging for direct script execution as well
+    logging.basicConfig(level=logging.INFO,
+                        format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
+                        stream=sys.stderr)
 
     # Define default input/output files for direct execution
     default_file1 = '1.xls'
     default_file2 = '2.xlsx'
-    default_output = '2_updated.xlsx'
+    default_output = '2_updated.xlsx' # For direct run, save locally
 
-    print(f"Running script directly. Processing {default_file1} and {default_file2}...")
-    # Use logger here too if desired, but print might be fine for direct runs
-    logger.info(f"Running script directly. Processing {default_file1} and {default_file2}...")
-    output_path = process_files(default_file1, default_file2, default_output)
+    logging.info(f"Running script directly. Processing {default_file1} and {default_file2}...")
+    # For direct run, let's keep saving locally for simplicity, unless specified otherwise
+    output_path = process_files(default_file1, default_file2, default_output) # Use local path for direct run
 
     if output_path:
-        print(f"Report generated successfully: {output_path}")
-        logger.info(f"Direct run: Report generated successfully: {output_path}")
+        logging.info(f"Report generated successfully: {output_path}")
     else:
-        print("Report generation failed.")
-        logger.error("Direct run: Report generation failed.")
+        logging.error("Report generation failed.")