Upload folder using huggingface_hub

Dockerfile

@@ -1,17 +1,14 @@
-FROM python:3.10-slim
+# Use a minimal base image with Python 3.9 installed
+FROM python:3.9-slim
 
+# Set the working directory inside the container to /app
 WORKDIR /app
 
-COPY requirements.txt /app/requirements.txt
-RUN pip install --no-cache-dir -r requirements.txt
+# Copy all files from the current directory on the host to the container's /app directory
+COPY . .
 
-# Copy streamlit app
-COPY app.py /app/app.py
+# Install Python dependencies listed in requirements.txt
+RUN pip3 install -r requirements.txt
 
-# Optional: baked-in backend base (override with env var in Space)
-ENV BACKEND_BASE="https://<your-backend-space>.hf.space"
-
-EXPOSE 7860
-
-# Start Streamlit (HF Spaces will handle proxy)
-CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]
+# Define the command to run the Streamlit app on port 7860 and make it accessible externally
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.enableCORS=false", "--server.address=0.0.0.0", "--server.enableXsrfProtection=false"]

app.py

@@ -1,180 +1,106 @@
-import os
-import json
-import time
-import requests
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import requests
+import time
 
-# -------------------------------
-# Config
-# -------------------------------
-# Prefer st.secrets; fallback to env var; lastly a hardcoded example
-BACKEND_BASE = st.secrets.get("BACKEND_BASE") or os.getenv("BACKEND_BASE") or "https://<your-backend-space>.hf.space"
-PREDICT_URL = f"{BACKEND_BASE}/predict"
-HEALTH_URL = f"{BACKEND_BASE}/health"
-FI_URL = f"{BACKEND_BASE}/feature_importance"
-
-st.set_page_config(page_title="SuperKart Sales Forecast", page_icon="🛒", layout="wide")
-
-# Maintain a small prediction history
-if "pred_history" not in st.session_state:
-    st.session_state.pred_history = []
-
-# -------------------------------
-# Header
-# -------------------------------
-st.title("🛒 SuperKart Sales Forecasting App")
-st.caption("Forecast product-level sales with store & product attributes. Deployed via Hugging Face Spaces.")
-
-# Health check
-health_col, base_col = st.columns([1, 3])
-with health_col:
+# Set the title of the Streamlit app
+st.set_page_config(page_title="SuperKart Sales Forecast", layout="centered")
+st.title("SuperKart Sales Prediction")
+
+# Health check endpoint for Hugging Face
+if st.query_params.get("healthcheck") == "true":
+    st.write("OK")
+    st.stop()
+
+# Section for single prediction
+st.subheader("Single Product-Store Prediction")
+
+# Collect user input for product and store features
+product_weight = st.number_input("Product Weight", min_value=0.1, max_value=20.0, value=12.65, step=0.1)
+product_allocated_area = st.number_input("Product Allocated Area Ratio", min_value=0.0, max_value=1.0, value=0.07, step=0.01)
+product_mrp = st.number_input("Product MRP", min_value=10, max_value=200, value=147, step=1)
+product_sugar_content = st.selectbox("Product Sugar Content", ["Low Sugar", "Regular", "No Sugar"])
+product_type = st.selectbox("Product Type", [
+    "Fruits and Vegetables", "Household", "Snack Foods", "Meat", 
+    "Hard Drinks", "Dairy", "Canned", "Soft Drinks", 
+    "Health and Hygiene", "Baking Goods", "Bread", "Breakfast",
+    "Frozen Foods", "Seafood", "Starchy Foods", "Others"
+])
+store_size = st.selectbox("Store Size", ["High", "Medium", "Low"])
+store_location_city_type = st.selectbox("Store Location City Type", ["Tier 1", "Tier 2", "Tier 3"])
+store_type = st.selectbox("Store Type", ["Departmental Store", "Supermarket Type 1", "Supermarket Type 2", "Food Mart"])
+store_age = st.number_input("Store Age (years)", min_value=1, max_value=50, value=10, step=1)
+product_category_code = st.number_input("Product Category Code", min_value=1, max_value=100, value=10, step=1)
+
+# Convert user input into the format expected by the API
+input_data = {
+    'Product_Weight': float(product_weight),
+    'Product_Allocated_Area': float(product_allocated_area),
+    'Product_MRP': int(product_mrp),
+    'Product_Sugar_Content': product_sugar_content,
+    'Product_Type': product_type,
+    'Store_Size': store_size,
+    'Store_Location_City_Type': store_location_city_type,
+    'Store_Type': store_type,
+    'Store_Age': int(store_age),
+    'Product_Category_Code': int(product_category_code)
+}
+
+# Make prediction when the "Predict" button is clicked
+if st.button("Predict Sales"):
     try:
-        r = requests.get(HEALTH_URL, timeout=3)
-        ok = r.status_code == 200 and r.json().get("status") == "ok"
-        if ok:
-            st.success("Backend: Online")
+        # Replace with your actual backend URL
+        backend_url = "https://simnid-superkartsalesbackend.hf.space/v1/predict"
+        response = requests.post(backend_url, json=input_data)
+        
+        if response.status_code == 200:
+            prediction = response.json()['Predicted Sales Total']
+            st.success(f"Predicted Sales Total: ${prediction:,.2f}")
         else:
-            st.warning("Backend: Unhealthy")
+            st.error(f"Error making prediction. Status code: {response.status_code}")
+            st.write(response.text)
     except Exception as e:
-        st.error("Backend: Unreachable")
-with base_col:
-    st.code(BACKEND_BASE, language="text")
-
-st.divider()
-
-# -------------------------------
-# Input Sidebar
-# -------------------------------
-with st.sidebar:
-    st.header("Input Parameters")
+        st.error(f"Error connecting to API: {e}")
 
-    st.subheader("Product")
-    product_id = st.text_input("Product_Id", value="PR123")
-    product_weight = st.number_input("Product_Weight (kg)", min_value=0.0, value=1.0, step=0.1)
-    product_sugar = st.selectbox("Product_Sugar_Content", ["Low Sugar", "Regular", "No Sugar"])
-    allocated_area = st.slider("Product_Allocated_Area (0-1)", min_value=0.0, max_value=1.0, value=0.10, step=0.01)
-    product_type = st.selectbox(
-        "Product_Type",
-        [
-            "Meat","Snack Foods","Hard Drinks","Dairy","Canned","Soft Drinks","Health and Hygiene",
-            "Baking Goods","Bread","Breakfast","Frozen Foods","Fruits and Vegetables","Household",
-            "Seafood","Starchy Foods","Others"
-        ],
-        index=11
-    )
-    mrp = st.number_input("Product_MRP", min_value=0.0, value=50.0, step=0.5)
+# Section for batch prediction
+st.subheader("Batch Prediction")
 
-    st.subheader("Store")
-    store_id = st.text_input("Store_Id", value="ST001")
-    store_year = st.number_input("Store_Establishment_Year", min_value=1950, max_value=2025, value=2015, step=1)
-    store_size = st.selectbox("Store_Size", ["Low", "Medium", "High"], index=1)
-    store_city = st.selectbox("Store_Location_City_Type", ["Tier 1", "Tier 2", "Tier 3"], index=1)
-    store_type = st.selectbox("Store_Type", ["Departmental Store", "Supermarket Type 1", "Supermarket Type 2", "Food Mart"], index=1)
+# Allow users to upload a CSV file for batch prediction
+uploaded_file = st.file_uploader("Upload CSV file for batch prediction", type=["csv"])
 
-    st.caption("Tip: These fields must match training columns. The backend pipeline handles encoding & scaling.")
-
-# -------------------------------
-# Payload builder & Validators
-# -------------------------------
-def build_payload():
-    return {
-        "Product_Id": product_id.strip(),
-        "Product_Weight": float(product_weight),
-        "Product_Sugar_Content": product_sugar,
-        "Product_Allocated_Area": float(allocated_area),
-        "Product_Type": product_type,
-        "Product_MRP": float(mrp),
-        "Store_Id": store_id.strip(),
-        "Store_Establishment_Year": int(store_year),
-        "Store_Size": store_size,
-        "Store_Location_City_Type": store_city,
-        "Store_Type": store_type
-    }
-
-def validate_payload(payload: dict) -> list:
-    errs = []
-    if not payload["Product_Id"]:
-        errs.append("Product_Id is required.")
-    if not payload["Store_Id"]:
-        errs.append("Store_Id is required.")
-    if not (0.0 <= payload["Product_Allocated_Area"] <= 1.0):
-        errs.append("Product_Allocated_Area must be in [0, 1].")
-    if payload["Product_MRP"] <= 0:
-        errs.append("Product_MRP must be > 0.")
-    if payload["Product_Weight"] < 0:
-        errs.append("Product_Weight must be ≥ 0.")
-    if not (1950 <= payload["Store_Establishment_Year"] <= 2025):
-        errs.append("Store_Establishment_Year out of range.")
-    return errs
-
-# -------------------------------
-# Main Layout
-# -------------------------------
-left, right = st.columns([1.1, 1])
-
-with left:
-    st.subheader("Prediction")
-    payload = build_payload()
-
-    with st.expander("Show request JSON", expanded=False):
-        st.json(payload)
-
-    predict_btn = st.button("🔮 Predict Sales", type="primary", use_container_width=True)
-
-    if predict_btn:
-        errors = validate_payload(payload)
-        if errors:
-            for e in errors:
-                st.error(e)
-        else:
-            t0 = time.time()
-            try:
-                res = requests.post(PREDICT_URL, json=payload, timeout=10)
-                if res.status_code == 200:
-                    pred = res.json().get("predicted_sales")
-                    dur = (time.time() - t0) * 1000
-                    st.metric("Predicted Sales Revenue", f"{pred:,.2f}", help=f"Latency: {dur:.0f} ms")
-                    # Record history
-                    row = payload.copy()
-                    row["Prediction"] = pred
-                    row["Latency_ms"] = round(dur, 0)
-                    st.session_state.pred_history.append(row)
-                else:
-                    st.error(f"Prediction failed ({res.status_code}). Details: {res.text}")
-            except Exception as ex:
-                st.exception(ex)
-
-    if st.session_state.pred_history:
-        st.markdown("### Recent Predictions")
-        df_history = pd.DataFrame(st.session_state.pred_history)[
-            ["Product_Id","Store_Id","Product_Type","Store_Type","Product_Allocated_Area","Product_MRP","Prediction","Latency_ms"]
-        ]
-        st.dataframe(df_history, use_container_width=True, hide_index=True)
-
-with right:
-    st.subheader("Model Insights")
-    show_importance = st.toggle("Show Feature Importance (top 20)", value=False)
-
-    if show_importance:
+# Make batch prediction when the "Predict Batch" button is clicked
+if uploaded_file is not None:
+    if st.button("Predict Batch"):
         try:
-            r = requests.get(FI_URL, timeout=5)
-            if r.status_code == 200:
-                imp = r.json()  # dict: feature -> importance
-                if isinstance(imp, dict) and len(imp) > 0:
-                    imp_df = pd.DataFrame(
-                        sorted(imp.items(), key=lambda x: x[1], reverse=True)[:20],
-                        columns=["Feature","Importance"]
-                    )
-                    st.bar_chart(imp_df.set_index("Feature"))
-                    with st.expander("Raw importance"):
-                        st.dataframe(imp_df, use_container_width=True, hide_index=True)
-                else:
-                    st.info("Feature importance not available for this model.")
+            # Replace with your actual backend batch URL
+            batch_backend_url = "https://simnid-superkartsalesbackend.hf.space/v1/predictbatch"
+            response = requests.post(batch_backend_url, files={"file": uploaded_file})
+            
+            if response.status_code == 200:
+                predictions = response.json()
+                st.success("Batch predictions completed!")
+                
+                # Display predictions in a nice format
+                predictions_df = pd.DataFrame.from_dict(predictions, orient='index', columns=['Predicted Sales'])
+                st.dataframe(predictions_df)
+                
+                # Add download button
+                csv = predictions_df.to_csv(index=True)
+                st.download_button(
+                    label="Download Predictions as CSV",
+                    data=csv,
+                    file_name="superkart_predictions.csv",
+                    mime="text/csv"
+                )
             else:
-                st.warning("Feature importance endpoint unavailable.")
+                st.error(f"Error making batch prediction. Status code: {response.status_code}")
         except Exception as e:
-            st.error(f"Could not fetch importance: {e}")
-
-st.divider()
-st.caption("Note: Pipeline performs encoding & scaling internally to avoid leakage and ensure consistency.")
+            st.error(f"Error connecting to API: {e}")
+
+# Add some information about the app
+st.sidebar.header("About")
+st.sidebar.info("""
+This app predicts sales totals for SuperKart products using a machine learning model.
+- **Single Prediction**: Enter details for one product-store combination
+- **Batch Prediction**: Upload a CSV file with multiple records
+""")

requirements.txt

@@ -1,3 +1,4 @@
-streamlit==1.37.0
 pandas==2.2.2
-requests==2.32.3
+requests==2.28.1
+streamlit==1.43.2
+numpy==2.0.2