Code added

app.py

@@ -0,0 +1,707 @@
+import streamlit as st
+from platform import python_version
+import os
+import pandas as pd
+from datetime import datetime
+import openpyxl
+from openpyxl.styles import PatternFill, Border, Side
+from openpyxl.utils.dataframe import dataframe_to_rows
+from openpyxl import Workbook
+# [theme]
+# primaryColor = "#E694FF"
+# backgroundColor = "#00172B"
+# secondaryBackgroundColor = "#0083B8"
+# textColor = "#C6CDD4"
+# font = "sans-serif"
+# add_selectbox = st.sidebar.selectbox(
+#     "How would you like to be contacted?",
+#     ("Email", "Home phone", "Mobile phone")
+# )
+
+# Using "with" notation
+# with st.sidebar:
+#     add_radio = st.radio(
+#         "Choose a shipping method",
+#         ("Standard (5-15 days)", "Express (2-5 days)")
+#     )
+def tut4(of):
+    u = of['U']  # assigning a list to columns of input file
+    v = of['V']
+    w = of['W']
+    t = of['T']
+
+    # calculating the avg value sum() returns summation and len() return length
+    avgu = [sum(u) / len(u)]
+    avgv = [sum(v) / len(v)]
+    avgw = [sum(w) / len(w)]
+
+    au = sum(u) / len(u)
+    av = sum(v) / len(v)
+    aw = sum(w) / len(w)
+
+    u_ = []
+    v_ = []
+    w_ = []
+
+    for i in u:
+        u_.append(i - au)  # pushing the element at back of list
+    for i in v:
+        v_.append(i - av)
+    for i in w:
+        w_.append(i - aw)
+
+    # filling the remaining spaces in the column with blank space using extend function
+    avgu.extend([''] * (len(u) - 1))
+    avgv.extend([''] * (len(u) - 1))
+    avgw.extend([''] * (len(u) - 1))
+
+    octs = [1, -1, 2, -2, 3, -3, 4, -4]
+
+    lenc = {}  # dictionary to store longest subsequence length for each octant
+    for i in octs:
+        lenc[i] = 0
+
+    octants = []  # list to store octants for each case
+
+    col2 = []  # column to store longest subsequence length for each octant
+    col4 = []  # column to store octants and time row
+    col5 = []  # column to store start time
+    col6 = []  # column to store end time
+
+    # loop to determine the octant and to store the octants
+    # and update the length of subsequence with maxmimum length each time
+    c = 1
+    p = 1
+    for i in range(len(u_)):
+        oc = 1
+        if (u_[i] > 0) and (v_[i] > 0) and (w_[i] > 0):
+            oc = 1
+        elif (u_[i]) < 0 and (v_[i]) > 0 and (w_[i]) > 0:
+            oc = 2
+        elif (u_[i]) < 0 and (v_[i]) < 0 and (w_[i]) > 0:
+            oc = 3
+        elif (u_[i]) > 0 and (v_[i]) < 0 and (w_[i]) > 0:
+            oc = 4
+        elif (u_[i]) > 0 and (v_[i]) > 0 and (w_[i]) < 0:
+            oc = -1
+        elif (u_[i]) < 0 and (v_[i]) > 0 and (w_[i]) < 0:
+            oc = -2
+        elif (u_[i]) < 0 and (v_[i]) < 0 and (w_[i]) < 0:
+            oc = -3
+        elif (u_[i]) > 0 and (v_[i]) < 0 and (w_[i]) < 0:
+            oc = -4
+
+        octants.append(oc)
+        if i > 0:
+            if oc == p:
+                c += 1
+            else:
+                c = 1
+        p = oc
+        lenc[oc] = max(lenc[oc], c)
+
+    octants.extend([''] * (len(u_) - len(octants)))
+
+    of['         '] = ''
+
+    col1 = []  # column to store the octant values
+    for i in octs:
+        col1.append(i)
+
+    col1.extend([''] * (len(u_) - len(col1)))
+    of['Octant ##'] = col1
+
+    # column to store the longest subsequence length for each octant value
+    for i in lenc.values():
+        col2.append(i)
+
+    col2.extend([''] * (len(u_) - len(col2)))
+    of['Longest Subsequence Length'] = col2
+
+    col3 = []  # column to store count of longest subsequence for each octant value
+
+    maxc = {}  # dictionary to store count of longest subsequence for each octant value
+    maxl = {}  # dictionary to store start and end time for each octant's longest subsequence
+    for i in octs:
+        maxc[i] = 0
+        maxl[i] = []
+
+    p = 0
+    c = 1
+    time = t[0]
+    f = 0
+    j = 0
+    # loop performing required operations to store count of longest subsequence for each octant value
+    # and start and end time for each longest subsequence of individual octant
+    for i in octants:
+        if f == 0:
+            time = t[j]
+            f = 1
+        oc = i
+        if oc == p:
+            c += 1
+        else:
+            c = 1
+            time = t[j]
+
+        if c == lenc[oc]:
+            maxc[oc] += 1
+            maxl[oc].append([time, t[j]])
+            f = 0
+
+        p = oc
+        j = j + 1
+
+    for i in maxc.values():
+        col3.append(i)
+
+    col3.extend([''] * (len(u_) - len(col3)))
+    of['Count '] = col3
+
+    of['      '] = ''
+
+    # forming the required output columns accordingly from this tut's output
+    for i in octs:
+        col4.append(i)
+        col5.append(lenc[i])
+        col6.append(maxc[i])
+
+        col4.append('Time')
+        col5.append('From')
+        col6.append('To')
+
+        for j in maxl[i]:
+            col5.append(j[0])
+            col6.append(j[1])
+
+        col4.extend([''] * (len(col6) - len(col4)))
+
+    cnt = len(col6)
+    col4.extend([''] * (len(u_) - len(col4)))
+    col5.extend([''] * (len(u_) - len(col5)))
+    col6.extend([''] * (len(u_) - len(col6)))
+
+    of['Octant ###'] = col4
+    of[' Longest Subsequence Length'] = col5
+    of['Count  '] = col6
+    return cnt
+
+
+def tut2(of, mod=5000):
+    u = of['U']  # assigning list to columns of input file
+    v = of['V']
+    w = of['W']
+
+    # calculating the avg value sum() returns summation and len() return length
+    avgu = [sum(u) / len(u)]
+    avgv = [sum(v) / len(v)]
+    avgw = [sum(w) / len(w)]
+
+    au = sum(u) / len(u)
+    av = sum(v) / len(v)
+    aw = sum(w) / len(w)
+
+    u_ = []
+    v_ = []
+    w_ = []
+
+    for i in u:
+        u_.append(i - au)  # pushing the element at back of list
+    for i in v:
+        v_.append(i - av)
+    for i in w:
+        w_.append(i - aw)
+
+    # filling the remaining spaces in the column with blank space
+    avgu.extend([''] * (len(u) - 1))
+    avgv.extend([''] * (len(u) - 1))
+    avgw.extend([''] * (len(u) - 1))
+
+    col = ['', 'User Input']
+    col.extend([''] * (len(u_) - 2))
+
+    ranges = (len(u_) + mod - 1) // mod
+
+    oc_id = ['Overall Count', 'Mod ' + str(mod)]
+    # loop for creating the mod range's column
+    for i in range(ranges):
+        if i == ranges - 1:
+            oc_id.append(str(i * mod) + '-' +
+                         str(min((i + 1) * mod - 1, len(u) - 1)))
+        else:
+            oc_id.append(str(i * mod) + '-' + str((i + 1) * mod - 1))
+
+    octs = [1, -1, 2, -2, 3, -3, 4, -4]
+    values = {}
+    xx = {}
+
+    ran = 2 + int(len(u_) / mod) + bool(len(u_) // mod) + 14 * \
+        (1 + int(len(u_) / mod) + bool(len(u_) // mod))
+
+    num = 2 + int(len(u_) / mod) + bool(len(u_) // mod)
+
+    # initializing the dictionary with value equal to 0 and blank spaces as per requirements
+    for i in octs:
+        values[i] = [0] * (ran)
+        values[i][1] = ''
+
+        for k in range(num - 1):
+            for j in range(5):
+                values[i][j + 14 * k + num] = ''
+
+        values[i][num + 5] = i
+        xx[i] = 0
+
+    octants = []
+
+    # dictionary to store position of octant in columns
+    inds = {}
+    inds[1] = num + 6
+    col[inds[1]] = "From"
+
+    for i in range(len(octs)):
+        if i > 0:
+            inds[octs[i]] = inds[octs[i - 1]] + 1
+
+    # loop to determine the octant and to store the counts of octants
+    # and to store the total transition count
+    p = 1
+    for i in range(len(u_)):
+        oc = 1
+        if (u_[i] > 0) and (v_[i] > 0) and (w_[i] > 0):
+            oc = 1
+        elif (u_[i]) < 0 and (v_[i]) > 0 and (w_[i]) > 0:
+            oc = 2
+        elif (u_[i]) < 0 and (v_[i]) < 0 and (w_[i]) > 0:
+            oc = 3
+        elif (u_[i]) > 0 and (v_[i]) < 0 and (w_[i]) > 0:
+            oc = 4
+        elif (u_[i]) > 0 and (v_[i]) > 0 and (w_[i]) < 0:
+            oc = -1
+        elif (u_[i]) < 0 and (v_[i]) > 0 and (w_[i]) < 0:
+            oc = -2
+        elif (u_[i]) < 0 and (v_[i]) < 0 and (w_[i]) < 0:
+            oc = -3
+        elif (u_[i]) > 0 and (v_[i]) < 0 and (w_[i]) < 0:
+            oc = -4
+
+        octants.append(oc)
+        values[oc][0] += 1
+        values[oc][2 + i // mod] += 1
+
+        if i > 0:
+            values[oc][inds[p]] += 1
+
+        p = oc
+
+    # formation and adjustment of octant id column
+    for i in range(3):
+        oc_id.append('')
+
+    oc_id.append('Overall Transition Count')
+    oc_id.append('')
+    oc_id.append('Count')
+    values[1][num + 4] = "To"
+
+    for i in range(len(octs)):
+        oc_id.append(octs[i])
+
+    p = octants[0]
+    # loop for individual mod range's transition count and table formation
+    for i in range(num - 2):
+
+        for j in range(3):
+            oc_id.append('')
+
+        oc_id.append('Mod Transition Count')
+
+        if i == num - 3:
+            oc_id.append(str(i * mod) + '-' +
+                         str(min((i + 1) * mod - 1, len(u) - 1)))
+        else:
+            oc_id.append(str(i * mod) + '-' + str((i + 1) * mod - 1))
+
+        values[1][inds[1] + 14 - 2] = "To"
+        col[inds[1] + 14] = "From"
+        oc_id.append("Octant #")
+
+        for j in octs:
+            oc_id.append(j)
+
+        for j in octs:
+            values[j][inds[1] + 14 - 1] = j
+
+        for j in range(mod * (i) + 1, min(mod * (i + 1), len(u_) - 1) + 1):
+            oc = octants[j]
+
+            if j > 0:
+                values[oc][inds[p] + 14] += 1
+            p = oc
+
+        for j in octs:
+            inds[j] += 14
+
+    oc_id.extend([''] * (len(u_) - len(oc_id)))
+
+    # forming the columns required from this tut's output
+    for i in octs:
+        values[i].extend([''] * (len(u_) - len(values[i])))
+
+    req1 = []
+    req2 = []
+    req3 = {}
+    for i in octs:
+        req3[i] = []
+
+    for i in range(len(oc_id)):
+        if i >= num + 4:
+            req1.append(col[i])
+            req2.append(oc_id[i])
+            for j in octs:
+                req3[j].append(values[j][i])
+
+    blank = [''] * (len(u_))
+    of['ok1'] = blank
+
+    req1.extend([''] * (len(u_) - len(req1)))
+    req2.extend([''] * (len(u_) - len(req2)))
+    of['ok2' + col[num + 3]] = req1
+    of[oc_id[num + 3]] = req2
+
+    i = 3
+    for j in octs:
+        req3[j].extend([''] * (len(u_) - len(req3[j])))
+        of['ok' + str(i) + values[j][num + 3]] = req3[j]
+        i = i + 1
+
+
+cols = {}
+cols[1] = 23
+cols[-1] = 24
+cols[2] = 25
+cols[-2] = 26
+cols[3] = 27
+cols[-3] = 28
+cols[4] = 29
+cols[-4] = 30
+
+
+def tut5(of, f, poss, mod=5000):
+    # try:
+    octant_name_id_mapping = {"1": "Internal outward interaction", "-1": "External outward interaction",
+                              "2": "External Ejection", "-2": "Internal Ejection",
+                              "3": "External inward interaction", "-3": "Internal inward interaction",
+                              "4": "Internal sweep", "-4": "External sweep"}
+    
+    u = of['U']  # assigning a list to columns of input file
+    v = of['V']
+    w = of['W']
+
+    # calculating the avg value sum() returns summation and len() returns length
+    avgu = [round(sum(u) / len(u), 3)]
+    avgv = [round(sum(v) / len(v), 3)]
+    avgw = [round(sum(w) / len(w), 3)]
+
+    au = round(sum(u) / len(u), 3)
+    av = round(sum(v) / len(v), 3)
+    aw = round(sum(w) / len(w), 3)
+
+    u_ = []
+    v_ = []
+    w_ = []
+
+    for i in u:
+        u_.append(round(i - au, 3))  # pushing the element at the end of list using append
+    for i in v:
+        v_.append(round(i - av, 3))
+    for i in w:
+        w_.append(round(i - aw, 3))
+
+    # filling the remaining spaces in the column with blank space using extend 
+    avgu.extend([''] * (len(u) - 1))
+    avgv.extend([''] * (len(u) - 1))
+    avgw.extend([''] * (len(u) - 1))
+
+    try:
+        of["U Avg"] = avgu  # creating a column in output file
+        of["V Avg"] = avgv
+        of["W Avg"] = avgw
+
+        of["U'=U-U avg"] = u_
+        of["V'=V-V avg"] = v_
+        of["W'=W-W avg"] = w_
+    except:
+        print('Error encountered : Mismatch in length of columns')
+
+    emp = [''] * (len(u_))
+    col = ['', 'Mod ' + str(mod)]
+    col.extend([''] * (len(u_) - 2))
+
+    ranges = (len(u_) + mod - 1) // mod
+
+    oc_id = ['Overall Count']
+
+    # loop for creating the mod range's column
+    for i in range(ranges):
+        if i == ranges - 1:
+            oc_id.append(str(i * mod) + '-' +
+                         str(min((i + 1) * mod - 1, len(u) - 1)))
+        else:
+            oc_id.append(str(i * mod) + '-' + str((i + 1) * mod - 1))
+
+    octs = [1, -1, 2, -2, 3, -3, 4, -4]
+    values = {}  # columns before ranking starts
+    ranks = {}  # columns containing ranks
+    rank = []
+    rank.extend([''] * (len(u_)))
+    name = []
+    name.extend([''] * (len(u_)))
+
+    ran = 2 + int(len(u_) / mod) + bool(len(u_) // mod) + 14 * \
+        (1 + int(len(u_) / mod) + bool(len(u_) // mod))
+
+    num = 1 + int(len(u_) / mod) + bool(len(u_) // mod)
+
+    # initializing the dictionary with value equal to 0 and blank spaces as per requirements
+    for i in octs:
+        values[i] = [''] * (len(u_))
+        values[i] = [0] * (num)
+        ranks[i] = [''] * (len(u_))
+        ranks[i] = [0] * (num)
+
+    octants = []
+
+    # loop to determine the octant and to store the counts of octants
+    # and to store the total transition count
+
+    for i in range(len(u_)):
+        oc = 1
+        if (u_[i] > 0) and (v_[i] > 0) and (w_[i] > 0):
+            oc = 1
+        elif (u_[i]) < 0 and (v_[i]) > 0 and (w_[i]) > 0:
+            oc = 2
+        elif (u_[i]) < 0 and (v_[i]) < 0 and (w_[i]) > 0:
+            oc = 3
+        elif (u_[i]) > 0 and (v_[i]) < 0 and (w_[i]) > 0:
+            oc = 4
+        elif (u_[i]) > 0 and (v_[i]) > 0 and (w_[i]) < 0:
+            oc = -1
+        elif (u_[i]) < 0 and (v_[i]) > 0 and (w_[i]) < 0:
+            oc = -2
+        elif (u_[i]) < 0 and (v_[i]) < 0 and (w_[i]) < 0:
+            oc = -3
+        elif (u_[i]) > 0 and (v_[i]) < 0 and (w_[i]) < 0:
+            oc = -4
+
+        octants.append(oc)
+        values[oc][0] += 1
+        values[oc][1 + i // mod] += 1
+
+    # formation and adjustment of octant id column
+    for i in range(3):
+        oc_id.append('')
+
+    try:
+        of['Octant'] = octants
+        of[' '] = emp
+        of[''] = col  # forming a column in output file
+    except:
+        print('Error encountered : Mismatch in length of columns')
+
+    oc_id.extend([''] * (len(u_) - len(oc_id)))
+    of['Octant ID'] = oc_id
+
+    cnt = {}
+    for i in octs:
+        cnt[i] = 0
+    
+    #loop to calculate rank of each octant for each mod range and assignment of the values
+    for i in range(num):
+        seq = []
+        for j in octs:
+            seq.append([values[j][i], j])
+        seq.sort()
+
+        for j in range(len(seq)):
+            ranks[seq[j][1]][i] = 8 - j
+
+        rank[i] = seq[len(seq) - 1][1]
+        poss.append([rank[i], i])
+        name[i] = octant_name_id_mapping[str(rank[i])]
+
+        if i != 0:
+            cnt[rank[i]] = cnt[rank[i]] + 1
+
+    for i in range(1):
+        ranks[4].append('')
+        ranks[-4].append('')
+
+    ranks[4].append('Octant ID')
+    ranks[-4].append('Octant Name')
+    rank[num + 1] = 'Count of Rank 1 Mod values'
+
+    # representation of name of each octant and count of rank 1 value
+    j = num + 2
+    for i in octs:
+        ranks[4].append(str(i))
+        ranks[-4].append(octant_name_id_mapping[str(i)])
+        rank[j] = cnt[i]
+        j = j + 1
+
+    #count of each octant in each mod range
+    for i in octs:
+        values[i].extend([''] * (len(u_) - len(values[i])))
+        of[str(i)] = values[i]
+    
+    #rank columns of each octant
+    for i in octs:
+        ranks[i].extend([''] * (len(u_) - len(ranks[i])))
+        of['Rank Octant ' + str(i)] = ranks[i]
+
+    #forming the output columns
+    of['Rank1 Octant ID'] = rank
+    of['Rank1 Octant Name'] = name
+
+
+
+opdir = 'output'
+def tut7(f):
+      # forming the output directory if not present
+    if not os.path.exists(opdir):
+        os.makedirs(opdir)
+
+    # for f in files:
+        # if ('input/' + f)[-4:] == 'xlsx':
+        # reading the input file
+    df = pd.read_excel(f)
+    of = df
+
+    u = of['U']
+    num = 2 + int(len(u) / mod) + bool(len(u) // mod)
+
+    # calling the required functions
+    poss = []
+    tut5(of, f, poss, mod)
+    tut2(of, mod)
+    cnt = int(tut4(of))
+
+    heads = []
+    c = 33
+    while c <= 43:
+        if c != 35:
+            heads.append(c)
+        c = c+1
+
+    # forming a dataframe in openpyxl from pandas dataframes
+    wb = Workbook()
+    sheet = wb.active
+    for r in dataframe_to_rows(df, index=False, header=True):
+        sheet.append(r)
+
+    yellow = "00FFFF00"
+
+    # coloring and bordering the required cells using openpxyl's
+    # patternfill and border function
+    for i in range(len(poss)):
+        c = cols[poss[i][0]]
+        r = int(poss[i][1]+2)
+        sheet.cell(row=r, column=c).fill = PatternFill(
+            patternType="solid", fgColor=yellow)
+
+    for i in range(len(heads)):
+        sheet.cell(row=1, column=heads[i]).value = ' '
+
+    c = 14
+    borcol = []
+    while c <= 32:
+        borcol.append(c)
+        c = c+1
+
+    black = '000000'
+    thin_border = Border(left=Side(style='thin', color=black),
+                            right=Side(style='thin', color=black),
+                            top=Side(style='thin', color=black),
+                            bottom=Side(style='thin', color=black))
+    for i in range(len(borcol)):
+        for j in range(num):
+            sheet.cell(row=j+1, column=borcol[i]).border = thin_border
+
+    for i in range(9):
+        sheet.cell(row=num + 2 + i, column=29).border = thin_border
+        sheet.cell(row=num + i + 2, column=30).border = thin_border
+        sheet.cell(row=num + i + 2, column=31).border = thin_border
+
+    borcol = []
+    c = 35
+    while c <= 43:
+        borcol.append(c)
+        c = c+1
+
+    ran = int(len(u)/mod)+bool(len(u) % mod)+1
+    row = 0
+    for k in range(ran):
+        row = row+2
+        for i in range(len(borcol)):
+            for j in range(9):
+                sheet.cell(
+                    row=row+1+j, column=borcol[i]).border = thin_border
+        row = row+12
+
+    c = 44
+    while c <= 46:
+        c = c+1
+        for i in range(9):
+            sheet.cell(row=i + 1, column=c).border = thin_border
+
+    for i in range(cnt+1):
+        sheet.cell(row=1 + i, column=49).border = thin_border
+        sheet.cell(row=i+1, column=50).border = thin_border
+        sheet.cell(row=i+1, column=51).border = thin_border
+
+    # forming the required output file by saving openpyxl dataframe
+    wb.save(os.path.join(
+            opdir, f.name[0:-4] + '_octant_analysis_mod_' + str(mod) + '.xlsx'))
+
+st.title('Get output file of CS384-2022 tut-7 for free')
+f=[]
+
+f = st.sidebar.file_uploader('Upload your input file in xlsx format', accept_multiple_files=True
+)
+# f = st.file_uploader('Upload your input file in xlsx format', accept_multiple_files=True)
+from zipfile import ZipFile
+
+mod=0
+if f is not None:
+    mod=int(st.number_input('Please enter mod value'))
+    if mod!=0:
+        
+        if st.button('Compute'):
+            cnt=100/len(f)
+            num=0
+            bar=st.progress(num)
+            for files in f:
+                num+=cnt
+                bar.progress(int(num))
+                # print(files.name)
+                tut7(files)        
+            
+    else:
+        st.warning('Mod cannot be zero', icon='🥱')
+    
+st.title('')
+st.write('Output files ready for download👇')
+opdir="output"
+for files in os.listdir(opdir):
+    # print(files)
+    st.download_button("Download "+(files), os.path.join(opdir,files), file_name=files)
+
+st.title('')
+st.write("Thank us later✌")
+
+# with ZipFile('my_python_files.zip','w') as zip:
+#     # writing each file one by one
+#     opdir="output"
+#     for file in opdir:
+#         zip.write(file)
+
+# print('All files zipped successfully!') 

requirements.txt.txt

@@ -0,0 +1,2 @@
+streamlit
+pandas