Upload folder using huggingface_hub

Dockerfile

@@ -1,20 +1,20 @@
-FROM python:3.13.5-slim
+# Use Python 3.9 slim image
+FROM python:3.9-slim
 
+# Set working directory
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+# Copy requirements first for better caching
+COPY requirements.txt .
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
 
-RUN pip3 install -r requirements.txt
+# Copy application files
+COPY . .
 
-EXPOSE 8501
+# Expose port 7860 (HuggingFace Spaces default)
+EXPOSE 7860
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Run Streamlit app
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0", "--server.enableXsrfProtection=false"]

app.py

@@ -0,0 +1,226 @@
+
+import streamlit as st
+import pandas as pd
+import requests
+import json
+
+# Configure page
+st.set_page_config(
+    page_title="SuperKart Sales Forecasting",
+    page_icon="🛒",
+    layout="wide"
+)
+
+# Backend API URL - Replace with your deployed backend URL
+BACKEND_URL = "https://huggingface.co/spaces/deepakdm411/ShoppingCartBackEnd"  # Replace with your actual backend URL
+
+st.title("🛒 SuperKart Sales Forecasting System")
+st.write("Predict sales revenue for SuperKart products using our advanced ML model")
+
+# API connection status
+def check_backend_connection():
+    try:
+        response = requests.get(f"{BACKEND_URL}/", timeout=10)
+        return response.status_code == 200
+    except:
+        return False
+
+# Check backend status
+with st.spinner("Checking API connection..."):
+    backend_online = check_backend_connection()
+
+if backend_online:
+    st.success("✅ Connected to backend API")
+else:
+    st.error("❌ Backend API not available. Please check the backend URL.")
+    st.info(f"Current backend URL: {BACKEND_URL}")
+
+st.subheader("Enter Product and Store Details:")
+
+# Create input form
+with st.form("prediction_form"):
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("**🏪 Store Information**")
+        store_type = st.selectbox(
+            "Store Type", 
+            ["Supermarket Type1", "Supermarket Type2", "Supermarket Type3", "Grocery Store"]
+        )
+        store_size = st.selectbox("Store Size", ["Small", "Medium", "High"])
+        store_location = st.selectbox("Store Location City Type", ["Tier 1", "Tier 2", "Tier 3"])
+        store_year = st.number_input("Store Establishment Year", min_value=1980, max_value=2024, value=2010)
+    
+    with col2:
+        st.markdown("**📦 Product Information**")
+        product_type = st.selectbox(
+            "Product Type", 
+            ["Dairy", "Soft Drinks", "Meat", "Fruits and Vegetables", "Household", 
+             "Baking Goods", "Snack Foods", "Frozen Foods", "Breakfast", 
+             "Health and Hygiene", "Hard Drinks", "Canned", "Bread", 
+             "Starchy Foods", "Others", "Seafood"]
+        )
+        product_sugar = st.selectbox("Product Sugar Content", ["Low Fat", "Regular"])
+        product_weight = st.number_input("Product Weight", min_value=0.01, value=1.0)
+        product_mrp = st.number_input("Product MRP", min_value=1.0, value=100.0)
+        product_area = st.number_input("Product Allocated Area", min_value=0.001, value=0.1)
+    
+    # Submit button
+    submitted = st.form_submit_button("🎯 Predict Sales Revenue", type="primary")
+
+# Handle form submission
+if submitted and backend_online:
+    # Prepare data for API
+    prediction_data = {
+        "Product_Weight": product_weight,
+        "Product_Sugar_Content": product_sugar,
+        "Product_Allocated_Area": product_area,
+        "Product_Type": product_type,
+        "Product_MRP": product_mrp,
+        "Store_Establishment_Year": store_year,
+        "Store_Size": store_size,
+        "Store_Location_City_Type": store_location,
+        "Store_Type": store_type
+    }
+    
+    # Make API call
+    with st.spinner("Making prediction..."):
+        try:
+            response = requests.post(
+                f"{BACKEND_URL}/predict",
+                json=prediction_data,
+                headers={"Content-Type": "application/json"},
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                
+                # Display results
+                st.success("✅ Prediction Complete!")
+                
+                # Main prediction display
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    st.metric(
+                        label="Predicted Sales Revenue",
+                        value=result["formatted_prediction"]
+                    )
+                
+                # Additional details
+                st.markdown("---")
+                st.markdown("### 📊 Prediction Details")
+                
+                detail_col1, detail_col2 = st.columns(2)
+                
+                with detail_col1:
+                    st.info(f"""
+                    **Store Profile:**
+                    - Type: {store_type}
+                    - Size: {store_size}
+                    - Location: {store_location}
+                    - Established: {store_year}
+                    """)
+                
+                with detail_col2:
+                    st.info(f"""
+                    **Product Profile:**
+                    - Category: {product_type}
+                    - Weight: {product_weight} kg
+                    - MRP: ₹{product_mrp}
+                    - Sugar Content: {product_sugar}
+                    """)
+                
+                # Business insights
+                prediction_value = result["prediction"]
+                if prediction_value > product_mrp * 10:
+                    st.success("🚀 Excellent Revenue Potential!")
+                elif prediction_value > product_mrp * 5:
+                    st.info("📈 Good Revenue Potential")
+                else:
+                    st.warning("📊 Moderate Revenue Potential")
+                    
+            else:
+                error_data = response.json()
+                st.error(f"Prediction failed: {error_data.get('error', 'Unknown error')}")
+                
+        except requests.exceptions.Timeout:
+            st.error("⏰ Request timed out. Please try again.")
+        except requests.exceptions.ConnectionError:
+            st.error("🔌 Connection error. Please check if backend is running.")
+        except Exception as e:
+            st.error(f"An error occurred: {str(e)}")
+
+elif submitted and not backend_online:
+    st.error("Cannot make prediction - backend API is not available.")
+
+# Sidebar with API information
+st.sidebar.markdown("### 🔧 API Information")
+if backend_online:
+    try:
+        model_info = requests.get(f"{BACKEND_URL}/model-info", timeout=10).json()
+        st.sidebar.success("✅ API Online")
+        st.sidebar.json(model_info)
+    except:
+        st.sidebar.warning("⚠️ Could not fetch model info")
+else:
+    st.sidebar.error("❌ API Offline")
+
+st.sidebar.markdown(f"**Backend URL:** {BACKEND_URL}")
+
+# Batch prediction section
+st.markdown("---")
+st.markdown("### 📁 Batch Predictions")
+
+with st.expander("Upload CSV for batch predictions"):
+    uploaded_file = st.file_uploader("Choose a CSV file", type="csv")
+    
+    if uploaded_file is not None and backend_online:
+        try:
+            # Read the uploaded file
+            df = pd.read_csv(uploaded_file)
+            st.write("Preview of uploaded data:")
+            st.dataframe(df.head())
+            
+            if st.button("Process Batch Predictions"):
+                # Convert dataframe to list of dictionaries
+                batch_data = {"predictions": df.to_dict('records')}
+                
+                with st.spinner("Processing batch predictions..."):
+                    response = requests.post(
+                        f"{BACKEND_URL}/batch-predict",
+                        json=batch_data,
+                        timeout=60
+                    )
+                    
+                    if response.status_code == 200:
+                        batch_results = response.json()
+                        
+                        st.success(f"✅ Processed {batch_results['successful_predictions']} predictions successfully!")
+                        
+                        # Create results dataframe
+                        if batch_results['predictions']:
+                            results_df = pd.DataFrame(batch_results['predictions'])
+                            st.dataframe(results_df)
+                            
+                            # Download results
+                            csv = results_df.to_csv(index=False)
+                            st.download_button(
+                                "📥 Download Results",
+                                csv,
+                                "batch_predictions.csv",
+                                "text/csv"
+                            )
+                    else:
+                        st.error("Batch prediction failed")
+                        
+        except Exception as e:
+            st.error(f"Error processing file: {str(e)}")
+
+# Footer
+st.markdown("---")
+st.markdown("""
+<div style='text-align: center; color: #666;'>
+    <p>SuperKart Sales Forecasting System | Built with Streamlit & Flask</p>
+</div>
+""", unsafe_allow_html=True)

requirements.txt

@@ -1,3 +1,3 @@
-altair
-pandas
-streamlit
+streamlit==1.43.2
+pandas==2.2.2
+requests==2.32.3