Update app.py

app.py

@@ -15,6 +15,8 @@ from io import BytesIO
 import base64
 from reportlab.platypus import Image
 import plotly.io as pio
+import sys
+import argparse
 
 # Load environment variables from .env file
 load_dotenv()
@@ -37,6 +39,9 @@ except Exception as e:
     logger.error(f"❌ Salesforce connection failed: {e}")
     sf = None
 
+# File to store forecast data
+DATA_FILE = "forecast_data.csv"
+
 def prepare_prophet_data(usage_series):
     end_date = datetime.now()
     start_date = end_date - timedelta(days=len(usage_series) - 1)
@@ -292,33 +297,76 @@ def upload_pdf_to_salesforce(pdf_file: BytesIO, consumable_type: str, record_id:
         logger.error(f"Error uploading PDF to Salesforce: {str(e)}")
         return None
 
-def main():
-    st.title("SmartLab Consumables Forecast")
-    st.header("Input Parameters")
-
-    consumable_type_label = st.selectbox("Consumable Type", ['Filters', 'Reagents', 'Vials'])
-    consumable_type = consumable_type_label
-    usage_series = st.text_input("Last 60 Days Usage (comma-separated)", "")
-    current_stock = st.number_input("Current Stock", min_value=0, value=0)
+def save_forecast_data(consumable_type, usage_series, current_stock, daily_forecasts):
+    """Save usage series, current stock, and daily forecasts to CSV."""
+    try:
+        # Convert usage series to string
+        usage_str = ','.join(map(str, usage_series))
+        # Prepare forecast data
+        forecast_data = {
+            'consumable_type': [consumable_type],
+            'usage_series': [usage_str],
+            'current_stock': [current_stock],
+            'forecast_date': [daily_forecasts['ds'].astype(str).tolist()],
+            'forecast_yhat': [daily_forecasts['yhat'].tolist()]
+        }
+        df = pd.DataFrame(forecast_data)
+        # Append to CSV or create new
+        if os.path.exists(DATA_FILE):
+            existing_df = pd.read_csv(DATA_FILE)
+            existing_df = existing_df[existing_df['consumable_type'] != consumable_type]  # Remove old data for this type
+            df = pd.concat([existing_df, df], ignore_index=True)
+        df.to_csv(DATA_FILE, index=False)
+        logger.info(f"Saved forecast data for {consumable_type} to {DATA_FILE}")
+    except Exception as e:
+        logger.error(f"Error saving forecast data: {str(e)}")
 
-    if st.button("Generate Forecast"):
-        usage_list, error = validate_usage_series(usage_series)
-        if error:
+def load_forecast_data(consumable_type):
+    """Load previous forecast data for a consumable type."""
+    try:
+        if not os.path.exists(DATA_FILE):
+            logger.warning(f"No forecast data file found at {DATA_FILE}")
+            return None, None, None
+        df = pd.read_csv(DATA_FILE)
+        row = df[df['consumable_type'] == consumable_type]
+        if row.empty:
+            logger.warning(f"No data found for {consumable_type} in {DATA_FILE}")
+            return None, None, None
+        usage_series = [float(x) for x in row['usage_series'].iloc[0].split(',')]
+        current_stock = float(row['current_stock'].iloc[0])
+        # Parse forecast data (stored as strings, need to eval safely)
+        forecast_dates = eval(row['forecast_date'].iloc[0])
+        forecast_yhat = eval(row['forecast_yhat'].iloc[0])
+        daily_forecasts = pd.DataFrame({'ds': pd.to_datetime(forecast_dates), 'yhat': forecast_yhat})
+        return usage_series, current_stock, daily_forecasts
+    except Exception as e:
+        logger.error(f"Error loading forecast data: {str(e)}")
+        return None, None, None
+
+def process_forecast(consumable_type, usage_series, current_stock, is_automated=False):
+    """Process forecast for a given consumable type."""
+    usage_list, error = validate_usage_series(','.join(map(str, usage_series)))
+    if error:
+        logger.error(error)
+        if not is_automated:
             st.error(error)
-            return
+        return None
 
-        try:
-            model = train_model_with_usage(usage_list)
-        except Exception as e:
+    try:
+        model = train_model_with_usage(usage_list)
+    except Exception as e:
+        logger.error(f"Error training model: {str(e)}")
+        if not is_automated:
             st.error(f"Error training model: {str(e)}")
-            return
+        return None
 
-        forecast_7 = make_forecast(model, 7)
-        forecast_14 = make_forecast(model, 14)
-        forecast_30 = make_forecast(model, 30)
-        daily_forecasts = get_daily_forecasts(model, 30)
-        reorder_date = calculate_reorder_date(model, current_stock)
+    forecast_7 = make_forecast(model, 7)
+    forecast_14 = make_forecast(model, 14)
+    forecast_30 = make_forecast(model, 30)
+    daily_forecasts = get_daily_forecasts(model, 30)
+    reorder_date = calculate_reorder_date(model, current_stock)
 
+    if not is_automated:
         st.header("Forecast Results")
         col1, col2, col3 = st.columns(3)
         col1.metric("7-Day Forecast", f"{forecast_7} units")
@@ -400,56 +448,164 @@ def main():
             template='plotly_white'
         )
         st.plotly_chart(fig_alerts)
+    else:
+        alert_status = [current_stock < forecast for forecast in [forecast_7, forecast_14, forecast_30]]
+        fig_daily = go.Figure()
+        fig_daily.add_trace(go.Scatter(
+            x=daily_forecasts['ds'],
+            y=daily_forecasts['yhat'],
+            mode='lines+markers',
+            name='Daily Forecast',
+            line=dict(color='royalblue', width=2),
+            marker=dict(size=8, color='darkorange', line=dict(width=2, color='black')),
+            fill='tozeroy',
+            fillcolor='rgba(0, 176, 246, 0.2)'
+        ))
+        y_values = daily_forecasts['yhat'].tolist()
+        fig_daily.update_layout(
+            title='Daily Consumable Usage Forecast (30 Days)',
+            xaxis_title='Date',
+            yaxis_title='Units',
+            template='plotly_white',
+            xaxis=dict(tickformat="%Y-%m-%d", tickangle=45, tickmode='auto', nticks=10),
+            yaxis=dict(range=[max(0, min(y_values) - 5), max(y_values) + 5], tickmode='linear', dtick=2),
+            showlegend=True,
+            legend=dict(x=0.01, y=0.99),
+            hovermode='x unified',
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
+            margin=dict(l=50, r=50, t=50, b=100)
+        )
+        alert_data = pd.DataFrame({
+            'Category': ['Current Stock', '7-Day Forecast', '14-Day Forecast', '30-Day Forecast'],
+            'Units': [current_stock, forecast_7, forecast_14, forecast_30],
+            'Alert': [False] + alert_status
+        })
+        fig_alerts = go.Figure()
+        fig_alerts.add_trace(go.Bar(
+            x=alert_data['Category'],
+            y=alert_data['Units'],
+            marker_color=['green'] + ['red' if alert else 'blue' for alert in alert_data['Alert'][1:]],
+            text=[f"🚩" if alert else "" for alert in alert_data['Alert']],
+            textposition='auto'
+        ))
+        fig_alerts.update_layout(
+            title='Stock vs Forecast with Alerts (🚩 indicates low stock)',
+            xaxis_title='Category',
+            yaxis_title='Units',
+            template='plotly_white'
+        )
 
-        # Salesforce record creation with PDF upload
-        if sf is not None:
-            try:
-                order_suggestions_text = f"7 Days: {max(0, forecast_7 - current_stock)} units, 14 Days: {max(0, forecast_14 - current_stock)} units, 30 Days: {max(0, forecast_30 - current_stock)} units"
-                forecast_data = {
-                    "Consumable Type": consumable_type,
-                    "Current Stock": current_stock,
-                    "7-Day Forecast": f"{forecast_7} units",
-                    "14-Day Forecast": f"{forecast_14} units",
-                    "30-Day Forecast": f"{forecast_30} units",
-                    "Order Suggestions": order_suggestions_text,
-                    "Reorder Recommendation": "Yes" if any(alert_status) else "No",
-                    "Reorder Date": reorder_date if reorder_date else "Not within 30 days"
-                }
-                pdf_file = generate_forecast_pdf(forecast_data, daily_forecasts, alert_status, current_stock, forecast_7, forecast_14, forecast_30, fig_daily, fig_alerts, usage_series)
-                sf_data = {
-                    'Consumable_Type__c': consumable_type,
-                    'Forecast_Period__c': '7days',
-                    'ForeCasted_Quantity__c': float(forecast_7),
-                    'ForeCasted_Quantity_14days__c': float(forecast_14),
-                    'ForeCasted_Quantity_30days__c': float(forecast_30),
-                    'Current_Stock__c': float(current_stock),
-                    'Order_Suggestions__c': order_suggestions_text,
-                    'Reorder_Recommendation__c': any(alert_status),
-                    'Reorder_Date__c': reorder_date,
-                    'Pdf_report__c': ''  # Placeholder for PDF URL
-                }
-                result = sf.Consumables_Forecaste__c.create(sf_data)
-                logger.info(f"Salesforce record created: {result}")
-
-                if pdf_file:
-                    pdf_url = upload_pdf_to_salesforce(pdf_file, consumable_type, result['id'])
-                    if pdf_url:
-                        sf.Consumables_Forecaste__c.update(
-                            result['id'],
-                            {"Pdf_report__c": pdf_url}
-                        )
-                        logger.info(f"PDF uploaded to Salesforce: {pdf_url}")
-                        
-                    else:
-                        logger.error("Failed to upload PDF to Salesforce")
-                        st.error("Failed to upload PDF to Salesforce")
+    # Salesforce record creation with PDF upload
+    if sf is not None:
+        try:
+            order_suggestions_text = f"7 Days: {max(0, forecast_7 - current_stock)} units, 14 Days: {max(0, forecast_14 - current_stock)} units, 30 Days: {max(0, forecast_30 - current_stock)} units"
+            forecast_data = {
+                "Consumable Type": consumable_type,
+                "Current Stock": current_stock,
+                "7-Day Forecast": f"{forecast_7} units",
+                "14-Day Forecast": f"{forecast_14} units",
+                "30-Day Forecast": f"{forecast_30} units",
+                "Order Suggestions": order_suggestions_text,
+                "Reorder Recommendation": "Yes" if any(alert_status) else "No",
+                "Reorder Date": reorder_date if reorder_date else "Not within 30 days"
+            }
+            pdf_file = generate_forecast_pdf(forecast_data, daily_forecasts, alert_status, current_stock, forecast_7, forecast_14, forecast_30, fig_daily, fig_alerts, ','.join(map(str, usage_series)))
+            sf_data = {
+                'Consumable_Type__c': consumable_type,
+                'Forecast_Period__c': '7days',
+                'ForeCasted_Quantity__c': float(forecast_7),
+                'ForeCasted_Quantity_14days__c': float(forecast_14),
+                'ForeCasted_Quantity_30days__c': float(forecast_30),
+                'Current_Stock__c': float(current_stock),
+                'Order_Suggestions__c': order_suggestions_text,
+                'Reorder_Recommendation__c': any(alert_status),
+                'Reorder_Date__c': reorder_date,
+                'Pdf_report__c': ''
+            }
+            result = sf.Consumables_Forecaste__c.create(sf_data)
+            logger.info(f"Salesforce record created: {result}")
+
+            if pdf_file:
+                pdf_url = upload_pdf_to_salesforce(pdf_file, consumable_type, result['id'])
+                if pdf_url:
+                    sf.Consumables_Forecaste__c.update(
+                        result['id'],
+                        {"Pdf_report__c": pdf_url}
+                    )
+                    logger.info(f"PDF uploaded to Salesforce: {pdf_url}")
+                    logger.info(f"PDF Report generated and uploaded to Salesforce: {pdf_url}")
                 else:
-                    logger.error("Failed to generate PDF")
+                    logger.error("Failed to upload PDF to Salesforce")
+                    if not is_automated:
+                        st.error("Failed to upload PDF to Salesforce")
+            else:
+                logger.error("Failed to generate PDF")
+                if not is_automated:
                     st.error("Failed to generate PDF")
-            except Exception as e:
-                logger.error(f"Error creating Salesforce record or uploading PDF: {e}", exc_info=True)
+        except Exception as e:
+            logger.error(f"Error creating Salesforce record or uploading PDF: {e}", exc_info=True)
+            if not is_automated:
                 st.error(f"Error saving to Salesforce: {str(e)}")
 
+    return daily_forecasts
+
+def automate_daily_forecast():
+    """Run daily forecast automation for all consumable types."""
+    consumable_types = ['Filters', 'Reagents', 'Vials']
+    for consumable_type in consumable_types:
+        logger.info(f"Processing automated forecast for {consumable_type}")
+        # Load previous data
+        usage_series, current_stock, prev_daily_forecasts = load_forecast_data(consumable_type)
+        
+        if usage_series is None or current_stock is None or prev_daily_forecasts is None:
+            logger.warning(f"No previous data for {consumable_type}. Skipping automation.")
+            continue
+
+        # Get 61st day forecast (first day of previous 30-day forecast)
+        next_day_usage = prev_daily_forecasts['yhat'].iloc[0]
+        # Update usage series: remove oldest day, append new day
+        usage_series = usage_series[1:] + [next_day_usage]
+        # Update current stock: subtract yesterday's forecasted usage
+        yesterday_usage = prev_daily_forecasts['yhat'].iloc[0]
+        current_stock = max(0, current_stock - yesterday_usage)
+
+        # Process forecast
+        daily_forecasts = process_forecast(consumable_type, usage_series, current_stock, is_automated=True)
+        if daily_forecasts is not None:
+            # Save new data
+            save_forecast_data(consumable_type, usage_series, current_stock, daily_forecasts)
+            logger.info(f"Completed automated forecast for {consumable_type}")
+        else:
+            logger.error(f"Failed to process forecast for {consumable_type}")
+
+def main():
+    parser = argparse.ArgumentParser(description="SmartLab Consumables Forecast")
+    parser.add_argument('--automated', action='store_true', help="Run in automated mode")
+    args = parser.parse_args()
+
+    if args.automated:
+        automate_daily_forecast()
+        return
+
+    st.title("SmartLab Consumables Forecast")
+    st.header("Input Parameters")
+
+    consumable_type_label = st.selectbox("Consumable Type", ['Filters', 'Reagents', 'Vials'])
+    consumable_type = consumable_type_label
+    usage_series = st.text_input("Last 60 Days Usage (comma-separated)", "")
+    current_stock = st.number_input("Current Stock", min_value=0, value=0)
+
+    if st.button("Generate Forecast"):
+        usage_list, error = validate_usage_series(usage_series)
+        if error:
+            st.error(error)
+            return
+
+        daily_forecasts = process_forecast(consumable_type, usage_list, current_stock, is_automated=False)
+        if daily_forecasts is not None:
+            save_forecast_data(consumable_type, usage_list, current_stock, daily_forecasts)
+
 if __name__ == "__main__":
     main()
     sf = None