def getIncrementedData():
dataFromDM = dailyData.objects.values( day=ExtractDay('when'),
month=ExtractMonth('when'),
year = ExtractYear('when') ).annotate(Sum('confirmedCases'),
Sum('curedCases'),
Sum('deathCases'))
dataFromDM= dataFromDM.order_by('month')
print(dataFromDM)
print(len(dataFromDM))
incrementedConfirmedCases,incrementedCuredCases, incrementedDeathCases = dfd(int), dfd(int), dfd(int)
temp1, temp2, temp3 = 25435,5000,800
for i in dataFromDM:
d='{}/{}/{}'.format(i['day'],i['month'],i['year'])
incrementedConfirmedCases[d]=(i['confirmedCases__sum'] - temp1)
incrementedCuredCases[d]=(i['curedCases__sum'] - temp2)
incrementedDeathCases[d]=(i['deathCases__sum'] - temp3)
temp1 = i['confirmedCases__sum']
temp2 = i['curedCases__sum']
temp3 = i['deathCases__sum']
#print(i['confirmedCases__sum'],d)
print(incrementedConfirmedCases)
print(incrementedCuredCases)
print(incrementedDeathCases)
dateOfCnfInc ,dataOfCnfInc = list(incrementedConfirmedCases.keys()), list(incrementedConfirmedCases.values())
dateOfCurInc ,dataOfCurInc = list(incrementedCuredCases.keys()), list(incrementedCuredCases.values())
dateOfDthInc ,dataOfDthInc = list(incrementedDeathCases.keys()), list(incrementedDeathCases.values())
return dateOfCnfInc ,dataOfCnfInc,dateOfCurInc ,dataOfCurInc,dateOfDthInc ,dataOfDthInc
def depenencyGraph(sentence):
leaf = nt('leaf', [
'id', 'form', 'lemma', 'ctag', 'tag', 'features', 'parent', 'pparent',
'drel', 'pdrel', 'left', 'right'
])
yield leaf._make([
0, 'ROOT_F', 'ROOT_L', 'ROOT_C', 'ROOT_P',
dfd(str), -1, -1, '_', '_', [], []
])
for node in sentence.split("\n"):
id_, form, lemma, ctag, tag, features, parent, drel = node.split(
"\t")[:-2]
node = leaf._make([
int(id_), form, lemma, ctag, tag, features,
int(parent), -1, drel, '__PAD__', [], []
])
features = dfd(str)
for feature in node.features.split("|"):
try:
features[feature.split("-")[0]] = feature.split("-")[1]
except IndexError:
features[feature.split("-")[0]] = ''
yield node._replace(features=features)
yield leaf._make([
0, 'ROOT_F', 'ROOT_L', 'ROOT_C', 'ROOT_P',
dfd(str), -1, -1, '_', '_', [], []
])
def rollNumberWise(roll):
brower = webdriver.Chrome(executable_path="C:\\chromedriver.exe",
chrome_options=options)
brower.get("https://govexams.com/knit/searchresult.aspx")
st_detail = dfd(list)
i = -1
while 1:
i += 1
if len(roll) == i:
break
print("--->", roll[i])
user = brower.find_element_by_xpath("//*[@id='txtrollno']").clear()
user = brower.find_element_by_xpath("//*[@id='txtrollno']").send_keys(
roll[i])
brower.find_element_by_xpath("//*[@id='btnSearch']").click()
select = Select(brower.find_element_by_id("ddlResult"))
text = []
el = brower.find_element_by_id('ddlResult')
for option in el.find_elements_by_tag_name('option'):
text.append(option.get_attribute("value"))
print(text)
if len(text) == 0:
print("Invalid student id", roll[i])
continue
text = text[::-1]
print(text)
#st_detail=semWise(text,roll[i])
semWise(text, roll[i])
def dependency_graph(self, tokens):
leaf = namedtuple('leaf', [
'id', 'form', 'lemma', 'ctag', 'tag', 'features', 'parent',
'pparent', 'drel', 'pdrel', 'left', 'right'
])
yield leaf._make([
0, 'ROOT_F', 'ROOT_L', 'ROOT_C', 'ROOT_P',
dfd(lambda: '__PAD__'), -1, -1, '_', '__PAD__', [], []
])
tags = self.template.tag(tokens)
tags = [wt[1] for wt in tags]
for idx, (word, pos) in enumerate(zip(tokens, tags)):
yield leaf._make([
idx + 1, word, word, pos, pos,
dfd(lambda: '__PAD__'), -1, -1, '_', '__PAD__', [], []
])
yield leaf._make([
0, 'ROOT_F', 'ROOT_L', 'ROOT_C', 'ROOT_P',
dfd(lambda: '__PAD__'), -1, -1, '_', '__PAD__', [], []
])
def getOverAllRank(batch, branch):
allRoll = rollNoGenerator(batch)[(branch - 1) * 74:branch * 74]
DataBase = Marks.objects.filter(roll__in=allRoll)
allMark = dfd(list)
for i in DataBase:
allMark[i.roll].append(round(i.obtain_marks / i.total_marks, 3))
allMrakWithRank = dfd(float)
for i in allMark:
allMrakWithRank[i] = round(sum(allMark[i]) / len(allMark[i]), 5)
allMrakWithRankSorted = sorted(allMrakWithRank.items(),
key=lambda x: x[1],
reverse=True)
return allMrakWithRankSorted
def solution(tickets):
def dfs():
stack,path=['ICN'],[]
while len(stack)>0:
top=stack[-1]
if top not in routes or len(routes[top])==0: path.append(stack.pop())
else: stack.append(routes[top].pop(0))
return path[::-1]
routes=dfd(list)
for key, value in tickets: routes[key].append(value)
for r in routes: routes[r].sort()
return dfs()
def solution(A, K):
l = len(A)
book = dfd(int)
book[A[0]] += 1
big = 1
left, right = 0, 0
while right < l-1:
right += 1
book[A[right]] += 1
big = max(big, book[A[right]])
if right-left+1-big > K: # overstride
book[A[left]] -= 1
left += 1
return right - left + 1
def solution(n, costs):
answer, edges = 0, dfd(list)
for n1, n2, w in costs:
edges[n1].append([w, n1, n2])
edges[n2].append([w, n2, n1])
connected, edge_list = [costs[0][0]], edges[costs[0][0]]
heapify(edge_list)
while edge_list:
w, _, n2 = heappop(edge_list)
if n2 not in connected:
connected.append(n2)
answer += w
for edge in edges[n2]:
if edge[2] not in connected: heappush(edge_list, edge)
return answer
def solution(A, K):
if len(A) <= K:
return len(A)
res = 0
tail = 0
book = dfd(int)
M = 0
for i in range(len(A)):
book[A[i]] += 1
M = max(M, book[A[i]])
if M+K <= res:
book[A[tail]] -= 1
tail += 1
else:
res += 1
return res
def dependencyGraph(conll_text):
leaf = nt(
'leaf',
['id', 'form', 'lemma', 'ctag', 'tag', 'features', 'parent', 'drel'])
for node in [0] + conll_text + [-1]:
if node in [0, -1]:
yield leaf._make(
[0, 'ROOT_F', 'ROOT_L', 'ROOT_C', 'ROOT_P',
dfd(str), -1, '_'])
else:
id_, form, lemma, ctag, tag, features, parent, drel = node.strip(
).split("\t")[:8]
yield leaf._make([
int(id_), form, lemma, ctag, tag, features,
int(parent), drel
])
def __init__(self, file):
"""Initialize variable and call
automated functions to extract and
decorate the data.
Arguments:
file {str} -- Relative or full path of
the input file
"""
self.file = file
# Use defaultdict for populating pairs
# and avoid KeyError with regular dict
self.cluster = dfd(list)
self.extract_coord()
self.calc_dist()
def semWise(textt, id):
brower = webdriver.Chrome(executable_path="C:\\chromedriver.exe",
chrome_options=options)
brower.get("https://govexams.com/knit/searchresult.aspx")
detail = dfd(list)
j = -1
while 1:
j += 1
if len(textt) - 1 == j:
break
user = brower.find_element_by_xpath("//*[@id='txtrollno']").clear()
user = brower.find_element_by_xpath("//*[@id='txtrollno']").send_keys(
id)
brower.find_element_by_xpath("//*[@id='btnSearch']").click()
select = Select(brower.find_element_by_id("ddlResult"))
select.select_by_value(textt[j])
brower.find_element_by_xpath("//*[@id='btnGo']").click()
brower.forward()
totalMarks = brower.find_element_by_xpath(
"//*[@id='lbltotlmarksDisp']").text
name = brower.find_element_by_xpath("//*[@id='lblname']").text
semester = brower.find_element_by_xpath("//*[@id='lblsem']").text
status = brower.find_element_by_xpath(
"//*[@id='tblYear']/tbody/tr[2]/td[2]").text
carryOver1 = brower.find_element_by_xpath(
"//*[@id='tblYear']/tbody/tr[3]/td[2]").text
yearOfResult = brower.find_element_by_xpath(
"//*[@id='lblsession']").text
print('year', yearOfResult)
yearOfResult = yearOfResult[-1:-8:-1][::-1]
carryOver = list(map(str, carryOver1.split(',')))
print(carryOver)
carryOver = [x for x in carryOver if len(x) > 2]
carryOver = ','.join(carryOver)
print(carryOver)
try:
obtain_mark, total_mark = map(float, totalMarks.split(' / '))
except:
obtain_mark, total_mark = float(totalMarks), 10.0
semester = semester[11::]
print()
print("semester", semester)
print("marks", totalMarks)
print("obtain_mark", obtain_mark)
print("total_mark", total_mark)
print("status", status)
print("yearOfResult", yearOfResult)
noOfCarry = 0
if len(carryOver) > 0:
carry_over_status = 1
print("carryOver", carryOver, len(carryOver.split(',')))
noOfCarry = len(carryOver.split(','))
try:
execute = Carryover(roll=id,
subject_code=carryOver,
semester=semester,
obtain_marks=obtain_mark,
year_of_result=yearOfResult)
execute.save()
except IntegrityError as e:
print("duplicate exception carryTable")
try:
execute1 = Marks(roll=id,
semester=semester,
year_of_result=yearOfResult,
obtain_marks=obtain_mark,
total_marks=total_mark,
status=status,
carry_over_status=noOfCarry)
execute1.save()
pass
except IntegrityError as e:
markss = Marks.objects.get(roll=id, semester=semester)
if markss.status != 'PASS':
markss.obtain_marks = obtain_mark
markss.total_marks = total_mark
markss.status = status
markss.carry_over_status = 1
markss.year_of_result = yearOfResult
markss.save()
print("duplicate Exception marksTable")
brower.back()
brower.refresh()
time.sleep(1)
def getData():
#get data directlly to scrape site
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# URL = 'https://www.mohfw.gov.in/'
# page = requests.get(URL)
# soup = BeautifulSoup(page.content, 'html.parser')
# tableData = soup.findAll('div', attrs={'class':'data-table table-responsive'})
# tableData = tableData[0].find('tbody')
# dataList=[]
# for i in tableData.findAll('tr'):
# data=[]
# for j,vlu in enumerate(i.findAll('td')):
# if j==1:
# data.append(vlu.text)
# elif j>1:
# data.append(filter_integer(vlu.text))
# if len(data)>2:
# dataList.append(data)
# total = ['Total number of confirmed cases in India']
# for vlu in dataList[-1]:
# total.append(filter_integer(vlu))
# print(total)
# del dataList[-1]
# #dataList[-1]=total
# for i in range(len(dataList)):
# dataList[i].insert(0, i+1)
# print(dataList)
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#get data from database
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
dataList = []
tconfirmCases,tcuredCases,tdeathCases=0,0,0
updateDate=0
for i,vlu in enumerate(dailyData.objects.filter(when__date=date.today()) ):
dataList.append([i+1, vlu.stateName, vlu.confirmedCases, vlu.curedCases, vlu.deathCases])
updateDate = vlu.when
tconfirmCases+=int(vlu.confirmedCases)
tcuredCases+= int(vlu.curedCases)
tdeathCases+= int(vlu.deathCases)
total = ['Total number of confirmed cases in India',tconfirmCases,tcuredCases,tdeathCases]
print('databse')
print(total, dataList)
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
confirmCases = dfd(list)
for i in dataList:
try:
confirmCases[ stateCode[i[1]] ].append(int(i[2]))
confirmCases[ stateCode[i[1]] ].append(i[1])
confirmCases[ stateCode[i[1]] ].append(stateCode[i[1]])
except:
print("Except from getData()")
sortedConfirmedCases = sorted(confirmCases.items(), key=lambda x: x[1] , reverse=True)
#print(sortedConfirmedCases)
sortedConfirmedCasesList = []
colorData = dict()
colorFill=dict()
c=0
c2=255
radius=32
for i in sortedConfirmedCases:
sortedConfirmedCasesList.append({
'centered': i[1][2],
'fillKey': i[1][2],
'radius': radius+((i[1][0])//1000)*2,
'state': i[1][1]+","+str(i[1][0])
})
colorFill[ i[1][2] ] = "rgb("+str(c2)+","+ str(0)+","+str(c) +")"
colorData[ i[1][2] ]={ 'fillKey': i[1][2] }
c+=(i[1][0])//200
radius-=1
return dataList, total,sortedConfirmedCasesList,colorData,colorFill, updateDate
def __init__(self,v):
self.graph=dfd(list)
self.V=v
def class_rank(request,flag=0):
branch_list={"CSE":"B. Tech. / Computer Science and Engineering",
"CE":"B. Tech. / Civil Engineering",
"EL":"B. Tech. / Electronics Engineering",
"EE":"B. Tech. / Electrical Engineering",
"MC":"B. Tech. / Mechanical Engineering",
"IT":"B. Tech. / Information Technology"
}
if flag==1:
if request.method=="POST":
batch=request.POST.get('batch','')
branch=request.POST.get('branch','')
year=int(request.POST.get('year',''))
branch=branch_list[branch]
year_with_semestetr=['0','1 - 2','3 - 4','5 - 6','7 - 8']
#batch='2020'
#branch="B. Tech. / Civil Engineering"
#year=3
print(batch,branch,year)
allroll=[]
allname=dfd(str)
rollformat=int(batch[2::])-4
rollformat1=rollformat+1
select1= Students.objects.filter(course=branch) & (Students.objects.filter(roll__startswith=str(rollformat)) | Students.objects.filter(roll__startswith=str(rollformat1)))
for stdnt in select1:
if stdnt.roll.startswith(str(rollformat)) and len(stdnt.roll)==5:
allroll.append(stdnt.roll)
allname[stdnt.roll]=stdnt.name
if stdnt.roll.startswith(str(rollformat1)) and len(stdnt.roll)==6:
allroll.append(stdnt.roll)
allname[stdnt.roll]=stdnt.name
#print(allroll,len(allroll))
final_data=dfd(dfd) #multidiamentional dict
for i in allroll:
select=Marks.objects.filter(roll=i)
list_detail=[]
for j in select:
list_detail.append([j.roll,j.semester,j.obtain_marks,j.total_marks])
print(list_detail)
list_detail=clearData(list_detail)
print(list_detail,'l')
for k in list_detail:
final_data[i][k[1]]=str(k[2])+'_'+str(k[3])
print(final_data)
print(len(final_data))
if len(final_data)==0:
return render(request,'classRank1.html',{"sem":'Result not available',"branch":branch,"batch":batch})
sem=year_with_semestetr[year]
if year==1:
roll,obtain_marks_list,c=prepareFinalData(final_data,year_with_semestetr,year,allname)
if c>40:
roll,obtain_marks_list,c=prepareFinalData(final_data,year_with_semestetr,year,allname,c)
if c>40:
return render(request,'classRank1.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":'Result not available',"branch":branch,"batch":batch})
return render(request,'classRank.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":'1',"branch":branch,"batch":batch})
return render(request,'classRank.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":sem,"branch":branch,"batch":batch})
if year==2:
roll,obtain_marks_list,c=prepareFinalData(final_data,year_with_semestetr,year,allname)
if c>40:
roll,obtain_marks_list,c=prepareFinalData(final_data,year_with_semestetr,year,allname,c)
if c>40:
return render(request,'classRank1.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":'Result not available',"branch":branch,"batch":batch})
return render(request,'classRank.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":'3',"branch":branch,"batch":batch})
return render(request,'classRank.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":sem,"branch":branch,"batch":batch})
if year==3:
roll,obtain_marks_list,c=prepareFinalData(final_data,year_with_semestetr,year,allname)
if c>40:
roll,obtain_marks_list,c=prepareFinalData(final_data,year_with_semestetr,year,allname,c)
if c>40:
return render(request,'classRank.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":'Result not available',"branch":branch})
return render(request,'classRank.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":'5',"branch":branch,"batch":batch})
return render(request,'classRank.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":sem,"branch":branch,"batch":batch})
if year==4:
roll,obtain_marks_list,c=prepareFinalData(final_data,year_with_semestetr,year,allname)
if c>40:
roll,obtain_marks_list,c=prepareFinalData(final_data,year_with_semestetr,year,allname,c)
if c>40:
return render(request,'classRank.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":'Result not available',"branch":branch,"batch":batch})
return render(request,'classRank.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":'7',"branch":branch,"batch":batch})
return render(request,'classRank.html',{"roll_list":roll,"mark":obtain_marks_list,"sem":sem,"branch":branch,"batch":batch})
return render(request,'classRank.html')
def initui(self):
global DATA
self.setWindowTitle(self.title)
self.setGeometry(self.upleft, self.upright, self.downleft,
self.downright)
self.plot_bar = QMainWindow(self).menuBar()
self.plot_file = self.plot_bar.addMenu('File')
self.plot_save_action = QAction('&Save as png', self)
self.plot_save_action.triggered.connect(self.savePNG)
self.plot_save_action.setShortcut('Ctrl+S')
self.plot_file.addAction(self.plot_save_action)
self.xl = QLabel("Select the column for X-Axis:")
self.yl = QLabel("Select the column for Y-Axis:")
self.poption = QLabel("Select the Plotting Style:")
self.xbox = QComboBox()
self.ybox = QComboBox()
self.pbox = QComboBox()
self.btn = QPushButton("PLOT THE GRAPH")
#defaultdict to store the data in form of
# dictionary so that it is easy to access
# column wise
self.dd = dfd(list)
for i in range(len(DATA[0])):
self.xbox.addItem(DATA[0][i])
self.ybox.addItem(DATA[0][i])
self.dd[DATA[0][i]]
for i in range(1, len(DATA)):
for j in range(len(DATA[i])):
try:
self.dd[DATA[0][j]].append(float(DATA[i][j]))
except:
pass
## print(self.dd)
self.pbox.addItem("Scatter Points")
self.pbox.addItem("Scatter Points with Smooth Lines")
self.pbox.addItem("Plot Lines")
self.tabs = QTabWidget()
self.tabs.resize(500, 500)
self.v_box = QVBoxLayout()
self.v_box.addWidget(self.plot_bar)
self.v_box.addWidget(self.xl)
self.v_box.addWidget(self.xbox)
self.v_box.addWidget(self.yl)
self.v_box.addWidget(self.ybox)
self.v_box.addWidget(self.poption)
self.v_box.addWidget(self.pbox)
self.v_box.addWidget(self.btn)
self.v_box.addWidget(self.tabs)
self.tab1, self.tab2, self.tab3 = None, None, None
self.t1x, self.t1y, self.t2x, self.t2y, self.t3x, self.t3y = None, None, None, None, None, None
self.btn.clicked.connect(self.fig)
self.setLayout(self.v_box)
def __rnafold_parser(self, data):
''' Parses the output from RNAfold -p and sets the Precursor properties'''
pattern = re.compile(r'[.()}{|,]+(?=\s\W[\s|-])|-?\d+\.\d+')
matches = pattern.findall(data)
if len(matches) != 9:
print(f'ERROR!\n{data}')
raise Exception('Could not parse the RNAfold output')
secondary, mfe, ppnotation, efe, ctd, ctdenergy, ctddist, freq, div = matches
# The predicted secondary strucuture with the lowest energy in dot-bracket notation and its MFE value
self.secondary = secondary
self.mfe = float(mfe)
# Pseudo bracket notation of pair probabilities and ensemble free energy (EFE)
self.pseudo = ppnotation
self.efe = float(efe)
# Centroid ensemble structure dot bracket notation, its free energy and distance from the ensemble
self.centroid = ctd
self.ctdenergy = float(ctdenergy)
self.ctddist = float(ctddist)
# The frequency of the MFE structure and the ensemble strucutral diversity (mean base pair distance)
self.freq = float(freq)
self.diversity = float(div)
# Parsing the RNAfold name_dp.ps for the base pairing probabilites
self.bpp = dfd(dict)
with open(f'{self.name}_dp.ps') as dp:
for line in dp:
if line == '%start of base pair probability data\n':
break
for line in dp:
try:
i, j, pb, ubox = line[:-1].split(' ')
if ubox == 'lbox':
break
except ValueError:
print(line)
raise Exception('Could not parse the base pair probability file from RNAfold')
self.bpp[int(i)][int(j)] = float(pb) ** 2
intput = lambda : map(int, input().split())
def solve():
N, = intput()
ans = bin(N)[2:].count('1')
for s in sums:
if s > N: break
x = N-s
pc = bin(x)[2:].count('1')
ans = min(ans, pc + dp[s])
return ans
if __name__ == '__main__':
fac = [1]
for i in range(2,16):
fac += [fac[-1]*i]
sz = len(fac)
dp = dfd(lambda : float('inf'))
for m in range(2**sz):
s = pc = 0
for b in range(sz):
if m & (1<<b):
s += fac[b]
pc += 1
dp[s] = min(dp[s], pc)
sums = sorted(dp)
T, = intput()
for _ in range(T):
print( solve() )
def getDataForPdf(batch, branch, year):
rankData = []
sortedRankData = []
msg = ''
marksWithDetail = []
stdName = dfd(str)
totalBacklog = 0
updateDate = 'NA'
msg = 'Result not available yet.....!'
allBranchRoll = rollNoGenerator(int(batch[2::]) - 4)
if branch == 'CE':
branchRoll = allBranchRoll[int(74 * branch_code['CE'] -
74):int(74 * branch_code['CE']):]
if branch == 'CSE':
branchRoll = allBranchRoll[int(74 * branch_code['CSE'] -
74):int(74 * branch_code['CSE']):]
if branch == 'EE':
branchRoll = allBranchRoll[int(74 * branch_code['EE'] -
74):int(74 * branch_code['EE']):]
if branch == 'EL':
branchRoll = allBranchRoll[int(74 * branch_code['EL'] -
74):int(74 * branch_code['EL']):]
if branch == 'ME':
branchRoll = allBranchRoll[int(74 * branch_code['ME'] -
74):int(74 * branch_code['ME']):]
if branch == 'IT':
branchRoll = allBranchRoll[int(74 * branch_code['IT'] -
74):int(74 * branch_code['IT']):]
std = Student.objects.filter(roll__in=branchRoll)
for i in std:
stdName[i.roll] = i.name
try:
allMarks1 = Marks.objects.filter(roll__in=branchRoll, semester=year)
allMarks2 = Marks.objects.filter(roll__in=branchRoll, semester=year[0])
if len(allMarks1) > len(allMarks2):
allMarks = allMarks1
else:
year = year[0]
allMarks = allMarks2
for i in allMarks:
updateDate = i.dinank
rankData.append({'y': i.obtain_marks, 'label': i.roll}, )
if i.carry_over_status > 0:
totalBacklog += 1
sortedAllData = sorted(allMarks,
key=lambda x: x.obtain_marks,
reverse=True)
sortedRankData = []
for idx, i in enumerate(sortedAllData):
sortedRankData.append({
'y': i.obtain_marks,
'label': i.roll + "(" + str(idx + 1) + ")"
})
marksWithDetail.append({
'roll': i.roll,
'name': stdName[i.roll],
'mark': i.obtain_marks,
'rank': str(idx + 1),
'status': i.carry_over_status
})
marksWithDetailRnk = sorted(marksWithDetail,
key=lambda x: int(x['rank']))
print('/////////', marksWithDetailRnk, updateDate)
# for idx,v in enumerate(marksWithDetailRnk):
# v['sno']=(idx+1)
if len(allMarks) != 0:
msg = ''
#print(i.obtain_marks,i.total_marks)
except:
print("Exception from class rank")
allDetailForPdf = dict()
allDetailForPdf['marksWithDetailRnk'] = marksWithDetailRnk
allDetailForPdf['batch'] = batch
allDetailForPdf['branch'] = branch
allDetailForPdf['year'] = year
allDetailForPdf['printDate'] = datetime.now()
allDetailForPdf['updateDate'] = updateDate
#batch,branch,year
#print('pppppppp',allDetailForPdf)
return allDetailForPdf
def classRank(request):
rankData = []
sortedRankData = []
msg = ''
marksWithDetail = []
stdName = dfd(str)
totalBacklog = 0
batch = ''
branch = 'NA'
year = ''
if request.method == 'POST':
batch = request.POST.get('batch', '')
branch = request.POST.get('branch', '')
year = request.POST.get('year', '')
msg = 'Result not available yet.....!'
allBranchRoll = rollNoGenerator(int(batch[2::]) - 4)
if branch == 'CE':
branchRoll = allBranchRoll[int(74 * branch_code['CE'] -
74):int(74 * branch_code['CE']):]
if branch == 'CSE':
branchRoll = allBranchRoll[int(74 * branch_code['CSE'] -
74):int(74 * branch_code['CSE']):]
if branch == 'EE':
branchRoll = allBranchRoll[int(74 * branch_code['EE'] -
74):int(74 * branch_code['EE']):]
if branch == 'EL':
branchRoll = allBranchRoll[int(74 * branch_code['EL'] -
74):int(74 * branch_code['EL']):]
if branch == 'ME':
branchRoll = allBranchRoll[int(74 * branch_code['ME'] -
74):int(74 * branch_code['ME']):]
if branch == 'IT':
branchRoll = allBranchRoll[int(74 * branch_code['IT'] -
74):int(74 * branch_code['IT']):]
std = Student.objects.filter(roll__in=branchRoll)
for i in std:
stdName[i.roll] = i.name
try:
allMarks1 = Marks.objects.filter(roll__in=branchRoll,
semester=year)
allMarks2 = Marks.objects.filter(roll__in=branchRoll,
semester=year[0])
if len(allMarks1) > len(allMarks2):
allMarks = allMarks1
else:
year = year[0]
allMarks = allMarks2
for i in allMarks:
rankData.append({'y': i.obtain_marks, 'label': i.roll}, )
if i.carry_over_status > 0:
totalBacklog += 1
sortedAllData = sorted(allMarks,
key=lambda x: x.obtain_marks,
reverse=True)
sortedRankData = []
for idx, i in enumerate(sortedAllData):
sortedRankData.append({
'y':
i.obtain_marks,
'label':
i.roll + "(" + str(idx + 1) + ")"
})
marksWithDetail.append({
'roll': i.roll,
'name': stdName[i.roll],
'mark': i.obtain_marks,
'rank': str(idx + 1),
'status': i.carry_over_status
})
marksWithDetail = sorted(marksWithDetail, key=lambda x: x['roll'])
#marksWithDetailRnk = sorted(marksWithDetail, key= lambda x : x['rank'])
for idx, v in enumerate(marksWithDetail):
v['sno'] = (idx + 1)
if len(allMarks) != 0:
msg = ''
#print(i.obtain_marks,i.total_marks)
except:
print("Exception from class rank")
context = {
'rankData': rankData,
'sortedRankData': sortedRankData,
'msg': msg,
'marksWithDetail': marksWithDetail,
'batch': batch,
'branch': branch_list[branch],
'year': year,
'totalStudent': len(marksWithDetail),
'totalBacklog': totalBacklog,
'visit': countVisitor(),
'batch': batch,
'branch_code': branch,
'year': year,
}
return render(request, 'classRank.html', context)
import requests
from bs4 import BeautifulSoup as bsp
from collections import defaultdict as dfd
import time
OLD_DATA=dfd(str)
OLD_DATA={"Total Confirmed cases (Indian)":"3491 *","Total Confirmed cases (Foreign)":"41 *","Cured/Discharged":"24","Death":"7"}
def updateDATA(oldData,newData):
oldData["Total Confirmed cases (Indian)"]=newData["Total Confirmed cases (Indian)"]
oldData["Total Confirmed cases (Foreign)"]=newData["Total Confirmed cases (Foreign)"]
oldData["Cured/Discharged"]=newData["Cured/Discharged"]
oldData["Death"]=newData["Death"]
def sendSMS(msg):
import requests
#SMS service: https://www.fast2sms.com/
url = "https://www.fast2sms.com/dev/bulk"
#API_KEY="YOUR_API_KEY"
API_KEY="60doIbMQSJGsW1275UZpxm8FHXw39eliVfucvP4KTNCqyahAtztLbrzVkeJZQDIpdNBO56cAoFPHT1i71" #its not correct key paste you KEY after signup fast2sms.com
querystring = {"authorization":API_KEY,"sender_id":"FSTSMS","message":msg,"language":"english","route":"p","numbers":"8287798091,988998***"}
headers = {
'cache-control': "no-cache"
}
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)