Update main.py

main.py

@@ -1,22 +1,12 @@
-from fastapi import FastAPI, HTTPException
+import asyncio
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
+import requests
 import pandas as pd
-import numpy as np
-import joblib
+import json
 
-
-# Load your trained model and encoders
-xgb_model = joblib.load("model/xgb_model.joblib")
-encoders = joblib.load("model/encoders.joblib")
-
-# Function to handle unseen labels during encoding
-def safe_transform(encoder, column):
-    classes = encoder.classes_
-    return [encoder.transform([x])[0] if x in classes else -1 for x in column]
-
-# Define FastAPI app
 app = FastAPI()
+
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -25,46 +15,52 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Endpoint for making predictions
-@app.post("/predict")
-def predict(customer_name: str,
-    customer_address: str,
-    customer_phone: str,
-    customer_email: str,
-    cod:str,
-    weight: str,
-    pickup_address: str,
-    origin_city_name: str,
-    destination_city_name: str,
-    origin_country: str):
-    # Convert input data to DataFrame
-    input_data = {
-        'customer_name': customer_name,
-        'customer_address': customer_address,
-        'customer_phone': customer_phone,
-        'customer_email': customer_email,
-        'cod': float(cod),
-        'weight': float(weight),
-        'pickup_address':pickup_address,
-        'origin_city.name':origin_city_name,
-        'destination_city.name':destination_city_name
-    }
-    input_df = pd.DataFrame([input_data])
-
-    # Encode categorical variables using the same encoders used during training
-    for col in input_df.columns:
-        if col in encoders:
-            input_df[col] = safe_transform(encoders[col], input_df[col])
-
-    # Predict and obtain probabilities
-    pred = xgb_model.predict(input_df)
-    pred_proba = xgb_model.predict_proba(input_df)
-
-    # Output
-    predicted_status = "Unknown" if pred[0] == -1 else encoders['status.name'].inverse_transform([pred])[0]
-    probability = pred_proba[0][pred[0]] * 100 if pred[0] != -1 else "Unknown"
+global page
+page = 1
+# Declare the continuous function as an async function.
+async def your_continuous_function():
+    import pandas as pd
+    import requests
+    import json
+    global page
+    while True:
+        print("data fetcher running.....")
+        
+        # Initialize an empty DataFrame to store the combined data
+        combined_df = pd.DataFrame()
+        
+              # Update the payload for each page
+        url = "https://dev3.api.curfox.parallaxtec.com/api/ml/order-list?sort=id&paginate=500&page="+str(page)
+        
+        payload = {}
+        headers = {
+                'Accept': 'application/json',
+                'X-Tenant': 'royalexpress'
+              }
+        
+        response = requests.request("GET", url, headers=headers, data=payload)
+        
+              # Sample JSON response
+        json_response = response.json()
+              # Extracting 'data' for conversion
+        data = json_response['data']
+        
+        df = pd.json_normalize(data)
+        
+              # Concatenate the current page's DataFrame with the combined DataFrame
+        combined_df = pd.concat([combined_df, df], ignore_index=True)
+        
+        data = combined_df[combined_df['status.name'].isin(['RETURN TO CLIENT', 'DELIVERED'])]
+        print("data collected from page : "+str(page))
+        page+=1
+        await asyncio.sleep(60)  # Adjust the sleep interval as needed
 
-    if predicted_status == "RETURN TO CLIENT":
-       probability = 100 - probability
+# Create a startup event.
+@app.on_event("startup")
+async def startup_event():
+    # Start the continuous function as a background task.
+    asyncio.create_task(your_continuous_function())
 
-    return {"Probability": round(probability,2)}
+@app.get("/test_api")
+def test_api():
+    return "kpi_result"