AI/Demand_forcasting/forcasting2.py

from flask import Flask, render_template, send_file, request, redirect, Response
import os
import pandas as pd
import warnings
import json
import requests
from urllib.request import urlopen
warnings.filterwarnings("ignore")

app = Flask(__name__)

@app.route("/", methods=["GET"])
def home():
    return 'forcasting app running'

######################################################################################################################
list_output=[]

def day(Num,get_url,get_url_token,post_url,post_url_token):

    import requests

    url = get_url

    payload = {}
    headers = {
    'Authorization': get_url_token
    }

    response = requests.request("GET", url, headers=headers, data=payload)
    #a=response.text
    # print(response.text)

    import pandas as pd
    
    df2 = pd.read_json(response.text, orient ='index')
    df2=df2.reset_index()
    df2.columns = ['key','value']
    #print(df2)
    a=df2['value'][0]
    
    j=json.loads(a)
    userdata = pd.DataFrame(j)
    #df1
    itemid=userdata[['itemname','itemid']]
    itemid.columns = ['ItemName', 'ItemId']
    
    #df1=pd.read_csv(r'./upload/' + name)
    #df1=df1[df1['obdate']!='01/01/0001']
    userdata.columns = ['journaldate','sum','itemid','itemname']
    
    
    # import pandas as pd
    # userdata = pd.read_csv(r'C:\Users\Bizga\Desktop\forcast\5yearsitems.csv')
    # itemid = userdata[['itemname', 'itemid']]
    #userdata['journaldate'] = pd.to_datetime(userdata['journaldate'])
    userdata["journaldate"] = userdata["journaldate"].astype(str)
    #userdata[["year", "month", "day"]] = userdata["journaldate"].str.split("/", expand = True)
    userdata[[ "day","month","year", ]] = userdata["journaldate"].str.split("-", expand = True)
    #userdata['Month-Year']=userdata['year'].astype(str)+'-'+userdata['month'].astype(str)
    item_unique_name = userdata['itemname'].unique()
    
    #df=pd.read_csv("C:\\Users\\Bizgaze\\2021_2022.csv")
    # Group the DataFrame by the 'item' column
    grouped = userdata.groupby('itemname')
    
    # Print the unique items in the 'item' column
    #print(grouped.groups.keys())
    
    # Iterate over the unique items and print the group data
    for item, userdata in grouped:
        print("itemname: ", item)
    
        item_id = userdata.iloc[-1]['itemid']
       
        print(item_id)
    
        userdata= userdata.groupby('journaldate').sum()
        userdata= userdata.reset_index()
        #print(userdata)
        fulldata=userdata[['journaldate','sum']]
        fulldata.columns = ["Dates","SALES"]
    #************************************************************************************************************************
    
        ## Use Techniques Differencing
        import pandas as pd
        from pandas import DataFrame

        
        # userdata=pd.read_csv(r"C:\Users\Bizgaze\ipynb files\TS forcasting\working\139470.csv")
        userdata=userdata[['journaldate','sum','itemid']]
        userdata.columns = ['Date', 'sales','sku']
        from statsmodels.tsa.stattools import adfuller
        
        DATE=[]
        SALES=[]
        
        
        def adf_test(series,userdata):
            result=adfuller(series)
            print('ADF Statistics: {}'.format(result[0]))
            print('p- value: {}'.format(result[1]))
            if result[1] <= 0.05:
                print("strong evidence against the null hypothesis, reject the null hypothesis. Data has no unit root and is stationary")
            else:
            #print(userdata)
                print(stationary_test(userdata))
                print("weak evidence against null hypothesis, time series has a unit root, indicating it is non-stationary ")
             
        #*********************************************    stationary or non-stationary **********************************************************   
        def stationary_test(userdata):
          data=pd.DataFrame(userdata)
          for i in range(1,13):
            print(i)
            sales_data=DataFrame()
            data['sales']=data['sales'].shift(i)
            data.dropna(inplace=True)
            #print( userdata['sales'])
            try:
              X=adf_test(data["sales"],userdata="nothing")
              if "non-stationary" in str(X):
                print("non-stationary")
              else:
                print("stationary")
                #print(userdata[["Date","sales"]])
                #df_sale=pd.DataFrame(userdata)
                DATE.append(data["Date"])
                SALES.append(data["sales"])
                #df4 = pd.concat([data, sales_data], axis=1)
                return "done"
                break
            except ValueError:
              pass
        
        try:
            adf_test(userdata["sales"],userdata)
        except ValueError:
            pass
        sales=pd.DataFrame(SALES).T
        dates=pd.DataFrame(DATE).T
        try:
            df4 = pd.concat([dates["Date"],sales["sales"]], axis=1)
            df4=df4.dropna()
            print(df4)
        except KeyError:
            df4=userdata[['Date','sales']]
            df4=df4.dropna()
            print(df4)
            pass
        
    #####################################################################################################################  
        userdata=df4
        a = userdata.iloc[-1]['Date']

        #userdata['Date'] = pd.to_datetime(userdata['Date'])
        userdata["Date"] = userdata["Date"].astype(str)
        print('after testing')
        print(userdata)
        userdata[["year", "month", "day"]] = userdata["Date"].str.split("-", expand = True)
        #userdata[["year", "month"]] = userdata["Month"].str.split("-", expand=True)
        #userdata = userdata[["year","month",'sum']]
        userdata["year"] = userdata["year"].astype(int)
        userdata["month"] = userdata["month"].astype(int)
        userdata["day"] = userdata["day"].astype(int)
    #####################################################################################################################
    
    
        list_dates=[]
        import datetime
    
        days=int(Num)+1
        import pandas as pd
        base_date=pd.to_datetime(a)
        for x in range(1,days):
              dates=(base_date + datetime.timedelta(days=x))
              dates=str(dates).replace(" 00:00:00","")
              #print(dates)
              list_dates.append(dates)
        fut_date = pd.DataFrame(list_dates)
        fut_date.columns = ["Dates"]
        
        future_dates=pd.DataFrame(list_dates)
    
        future_dates.columns=["Dates"]
        future_dates[["year", "month", "day"]] = future_dates["Dates"].str.split("-", expand=True)
        future_dates.drop(['Dates'], axis=1, inplace=True)
        future_dates["year"] = future_dates["year"].astype(int)
        future_dates["month"] = future_dates["month"].astype(int)
        future_dates["day"] = future_dates["day"].astype(int)
        #print(future_dates)
    
    
    
        ###############################################################################
        userdata['sales']=userdata["sales"].astype(float)
        dependent = userdata[['year','month','day']]
        independent = userdata['sales']
    
        import numpy as np
        import pandas as pd
    
        import xgboost
        from sklearn.model_selection import train_test_split
        from sklearn.model_selection import GridSearchCV
        from sklearn.metrics import roc_auc_score
    
        import matplotlib.pyplot as plt
    
        #model = xgboost.XGBRegressor()
        from sklearn.ensemble import RandomForestRegressor
        model = RandomForestRegressor(random_state=1,n_jobs=-1)
        #model.fit(dependent, independent)
        model.fit(dependent, independent)
        #future=pd.read_csv('future_dates.csv')
    
    
        future_prediction = model.predict(future_dates)
        #print(future_prediction)
        df=pd.DataFrame(future_prediction)
        df.columns = ["SALES"]
        frames = [fut_date, df]
      
      
        result = pd.concat(frames,axis=1)
        result['itemname'] = item
        result['itemid'] =item_id 
        result.columns = ['Date','Predict','ItemName','ItemId']
        #result['Predict']=result["Predict"].astype(int)
        result['UpperLimit']=result["Predict"].mean()+result['Predict'].std()*3
        result['LowerLimit']=result['Predict'].mean()-result['Predict'].std()*3
        print(result)
        result.to_json('forcast.json', orient="records")
    
    
        with open('forcast.json', 'r') as json_file:
            json_load = json.load(json_file)
            #url = "https://demo.bizgaze.app/apis/v4/bizgaze/integrations/demandforecast/saveforecast/List"
            url=post_url
    
            payload = json.dumps(json_load)#.replace("]", "").replace("[", "")
            print(payload)
        #print(payload)
            headers = {
            #'Authorization': 'stat 263162e61f084d3392f162eb7ec39b2c',#demo
            'Authorization': post_url_token,#test
            'Content-Type': 'application/json'
            }
            response = requests.request("POST", url, headers=headers, data=payload)
        # print("##############################################################")
            print(response.text)

    
    return 'done'



#############################################################################################################################################################


def month(Num,get_url,get_url_token,post_url,post_url_token):
    #url='https://qa.bizgaze.app/apis/v4/bizgaze/integrations/demandforecast/getitemdata'
    # url= get_url
    # response = urlopen(url)
    # data_json = json.loads(response.read())
    # headers = {
    #         'Authorization':get_url_token,
    #         #'Authorization':'stat 873f2e6f70b3483e983972f96fbf5ea4',#qa
    #         'Content-Type': 'application/json'
    # }
    # response = requests.request("GET", url, headers=headers, data=data_json)
    # #print("##############################################################")
    # a=response.text
    # # print(response.text)
    import requests

    url = get_url

    payload = {}
    headers = {
    'Authorization': get_url_token
    }

    response = requests.request("GET", url, headers=headers, data=payload)

    #print(response.text)

    import pandas as pd
    
    df2 = pd.read_json(response.text, orient ='index')
    df2=df2.reset_index()
    df2.columns = ['key','value']
    #print(df2)
    a=df2['value'][0]
    
    j=json.loads(a)
    userdata = pd.DataFrame(j)

    #filePath='path.csv'
    # if os.path.exists(filePath):
    #     print('file exist')
    #     os.remove('path.csv')
    # else:
    #     print("file doesn't exists")
    #     pass
    #userdata=df
    itemid=userdata[['itemname','itemid']]
    itemid.columns = ['ItemName', 'ItemId']
    
    #df1=pd.read_csv(r'./upload/' + name)
    #df1=df1[df1['obdate']!='01/01/0001']
    userdata.columns = ['journaldate','sum','itemid','itemname']
    # import pandas as pd
    # userdata = pd.read_csv(r'C:\Users\Bizga\Desktop\forcast\5yearsitems.csv')
    # itemid = userdata[['itemname', 'itemid']]
    #userdata['journaldate'] = pd.to_datetime(userdata['journaldate'])
    userdata["journaldate"] = userdata["journaldate"].astype(str)
    #userdata[["year", "month", "day"]] = userdata["journaldate"].str.split("-", expand = True)
    userdata[[ "day","month","year", ]] = userdata["journaldate"].str.split("-", expand = True)
    #userdata[["year", "day", "month"]] = userdata["journaldate"].str.split("/", expand=True)
    userdata['Month-Year']=userdata['year'].astype(str)+'-'+userdata['month'].astype(str)
    item_unique_name = userdata['itemname'].unique()
    
    #df=pd.read_csv("C:\\Users\\Bizgaze\\2021_2022.csv")
    # Group the DataFrame by the 'item' column
    grouped = userdata.groupby('itemname')
    
    # Print the unique items in the 'item' column
    #print(grouped.groups.keys())
    
    # Iterate over the unique items and print the group data
    for item, userdata in grouped:
        print("itemname: ", item)
    
        item_id = userdata.iloc[-1]['itemid']
       
        print(item_id)
    
        userdata= userdata.groupby('Month-Year').sum()
        userdata= userdata.reset_index()
      
        fulldata=userdata[['Month-Year','sum']]
        fulldata.columns = ["Dates","SALES"]
    #************************************************************************************************************************
    
        ## Use Techniques Differencing
        import pandas as pd
        from pandas import DataFrame
        
        # userdata=pd.read_csv(r"C:\Users\Bizgaze\ipynb files\TS forcasting\working\139470.csv")
        userdata=userdata[['Month-Year','sum','itemid']]
        userdata.columns = ['Month', 'sales','sku']
        from statsmodels.tsa.stattools import adfuller
        
        DATE=[]
        SALES=[]
        
        
        def adf_test(series,userdata):
            result=adfuller(series)
            print('ADF Statistics: {}'.format(result[0]))
            print('p- value: {}'.format(result[1]))
            if result[1] <= 0.05:
                print("strong evidence against the null hypothesis, reject the null hypothesis. Data has no unit root and is stationary")
            else:
            #print(userdata)
                print(stationary_test(userdata))
                print("weak evidence against null hypothesis, time series has a unit root, indicating it is non-stationary ")
            
                
        #*********************************************    stationary or non-stationary **********************************************************   
        def stationary_test(userdata):
          data=pd.DataFrame(userdata)
          for i in range(1,13):
            print(i)
            sales_data=DataFrame()
            data['sales']=data['sales'].shift(i)
            data.dropna(inplace=True)
            #print( userdata['sales'])
            try:
              X=adf_test(data["sales"],userdata="nothing")
              if "non-stationary" in str(X):
                print("non-stationary")
              else:
                print("stationary")
                #print(userdata[["Month","sales"]])
                #df_sale=pd.DataFrame(userdata)
                DATE.append(data["Month"])
                SALES.append(data["sales"])
                #df4 = pd.concat([data, sales_data], axis=1)
                return "done"
                break
            except ValueError:
              pass
        
        try:
            adf_test(userdata["sales"],userdata)
        except ValueError:
            pass
        sales=pd.DataFrame(SALES).T
        dates=pd.DataFrame(DATE).T
        try:
            df4 = pd.concat([dates["Month"],sales["sales"]], axis=1)
            df4=df4.dropna()
            print(df4)
        except KeyError:
            df4=userdata[['Month','sales']]
            df4=df4.dropna()
            print(df4)
            pass
        
    #####################################################################################################################  
        userdata=df4
        a = userdata.iloc[-1]['Month']
        userdata[["year", "month"]] = userdata["Month"].str.split("-", expand=True)
        #userdata = userdata[["year","month",'sum']]
        userdata["year"] = userdata["year"].astype(int)
        userdata["month"] = userdata["month"].astype(int)
    #####################################################################################################################
    
        #a = userdata.iloc[-1]['Month-Year']
        from datetime import datetime
        from dateutil.relativedelta import relativedelta
        import pandas as pd
        months_value = int(Num)+1
        base_month = pd.to_datetime(a)
        list_months = []
        
        def months(MD):
            date_after_month = ((base_month + relativedelta(months=MD)).strftime('%Y-%m'))
            # print
            list_months.append(date_after_month)
        
        for i in range(1, months_value):
            months(i)
        
        future_dates = pd.DataFrame(list_months)
        
        future_dates.columns = ["Dates"]
    
        fut_date = pd.DataFrame(list_months)
        fut_date.columns = ["Dates"]
        
        future_dates[["year", "month"]] = future_dates["Dates"].str.split("-", expand=True)
        future_dates.drop(['Dates'], axis=1, inplace=True)
        future_dates["year"] = future_dates["year"].astype(int)
        future_dates["month"] = future_dates["month"].astype(int)
        
    
    
    
        ###############################################################################
        userdata['sales']=userdata["sales"].astype(float)
        dependent = userdata[['year','month']]
        independent = userdata['sales']
    
        import numpy as np
        import pandas as pd
    
        import xgboost
        from sklearn.model_selection import train_test_split
        from sklearn.model_selection import GridSearchCV
        from sklearn.metrics import roc_auc_score
    
        import matplotlib.pyplot as plt
    
        #model = xgboost.XGBRegressor()
        from sklearn.ensemble import RandomForestRegressor
        model = RandomForestRegressor(random_state=1,n_jobs=-1)
        model.fit(dependent, independent)
        #future=pd.read_csv('future_dates.csv')
    
    
        future_prediction = model.predict(future_dates)
        #print(future_prediction)
        df=pd.DataFrame(future_prediction)
        df.columns = ["SALES"]
        frames = [fut_date, df]
      
      
        result = pd.concat(frames,axis=1)
        result['itemname'] = item
        result['itemid'] =item_id 
        result.columns = ['Date','Predict','ItemName','ItemId']
        #result['Predict']=result["Predict"].astype(int)
        result['UpperLimit']=result["Predict"].mean()+result['Predict'].std()*3
        result['LowerLimit']=result['Predict'].mean()-result['Predict'].std()*3
        result["LowerLimit"][result["LowerLimit"] < 0] = 0
        print(result)
        result.to_json('forcast.json', orient="records")
    
        with open('forcast.json', 'r') as json_file:
            json_load = json.load(json_file)
            #url = "https://demo.bizgaze.app/apis/v4/bizgaze/integrations/demandforecast/saveforecast/List"
            url=post_url
    
            payload = json.dumps(json_load)#.replace("]", "").replace("[", "")
            print(payload)
        #print(payload)
            headers = {
            #'Authorization': 'stat 263162e61f084d3392f162eb7ec39b2c',#demo
            'Authorization': post_url_token,#test
            'Content-Type': 'application/json'
            }
            response = requests.request("POST", url, headers=headers, data=payload)
        # print("##############################################################")
            print(response.text)

    
    #output={"response":"success","result":json_data}
    #print(output)
    return 'done'



###############################################################################################################################################################

#####################################################################################################################

@app.route("/sales_forcast", methods=["GET", "POST"])
def sales_forcast():
    #wise= request.args.get('wise').replace('{','').replace('}','')
    #Num= request.args.get('value').replace('{','').replace('}','')
    #print(wise)
    #print(Num)
    Dataset = request.get_json()
    a = Dataset
    wise = a['wise']
    # print(x)
    Num = a['future_dates']
    get_url = a['get_url']
    get_url_token = a['get_url_token']
    post_url = a['post_url']
    post_url_token = a['post_url_token']

    #print(Dataset)
    # import pandas as pd
    # df=pd.DataFrame(Dataset)
    # print(df)
    # a = Dataset
    #x = a['wise']
    # cmd = "python C:\\Users\\Bizga\\Desktop\\forcast\\XGdaywise.py"
    # os.system(cmd)
   
    #split=wise
    # wise='month'
    # Num=5
    if wise=='days':
        print('daywise groupby')
        output=day(Num,get_url,get_url_token,post_url,post_url_token)
        # cmd = "python C:\\Users\\Bizga\\Desktop\\forcast\\XGdaywise.py"+" "+ Num
        # os.system(cmd)
    else:
        print('monthwise groupby')
        output=month(Num,get_url,get_url_token,post_url,post_url_token)
        # payload = json.dumps(output)
        # payload_list="["+payload+"]"

    return output

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=8082)