def getNetwork_configById(request):
id = request.REQUEST.get('id', None)
result = {}
if id is None or id == 0:
return HttpResponse(json.dumps(result),
content_type="application/json")
key_list = [
'id', 'device_name', 'idc_name', 'manage_ip', 'other_ip', 'dev_type',
'dev_ports', 'sn', 'an', 'units', 'rack_number', 'rack_units'
]
# sql = Sql.get_s_sql('network_config', key_list, {"id": id})
nw = networkingmodel()
r = nw.find({"id": id})
result = Query.fSqlResult(r, key_list)
key_list = ['id', 'room_name']
# sql = Sql.get_s_sql('room', key_list, {})
rm = roommodel()
r = rm.find({})
room = Query.fSqlResult(r, key_list)
key_list_1 = ['id', 'idc_name']
# sql_1 = Sql.get_s_sql('idc', key_list_1, {})
rk = rackmodel()
r_1 = rk.find({})
idc = Query.fSqlResult(r_1, key_list_1)
ret = {'result': result[0], 'idc': idc, 'room': room}
return HttpResponse(json.dumps(ret), content_type="application/json")
def run_an_experiment(dbname, alg, queries, appendage):
script_dir = os.path.dirname(__file__)
prefix = os.path.join(script_dir,
"Experiment3/" + dbname + alg + appendage)
if alg == "None":
q = Query.BreadthQueryer(dbname)
else:
q = Query.SummaryQueryer(dbname, alg)
macro = open(prefix + "Macro.csv", "w")
print(q.get_macro_headers(), file=macro)
numQs = len(queries)
currQNum = 1
for query in queries:
output = q.connection_query(query[0], query[1], query[2])
mac = output
mic = None
if alg != 'None':
mac = output[0]
mic = output[1]
micro = open(prefix + "Trial" + str(q.trial_num) + ".csv", "w")
print(q.get_micro_headers(), file=micro)
micro.write(mic)
micro.close()
print(mac, file=macro)
macro.flush()
print("Completed Query Number %d out of %d" % (currQNum, numQs))
currQNum += 1
q.close_connection()
def rack_jgt(request):
key_list = [
'id', 'idc_name', 'rack_number', 'start_time', 'end_time',
'service_provider'
]
rk = rackmodel()
r = rk.find({})
result = Query.fSqlResult(r, key_list)
key_list_1 = [
'id', 'hostname', 'manage_ip', 'other_ip', 'app_name', 'cpu', 'mem',
'disk', 'sn', 'an', 'units', 'idc_name', 'rack_number', 'rack_units',
'status', 'system_version'
]
new_result = []
for srv in result:
sv = servermodel()
r_1 = sv.find({"idc_name": srv['id']})
servers = Query.fSqlResult(r_1, key_list_1)
idc_name = srv['idc_name']
new_result.append([idc_name, servers])
return render(request, 'rack/rack_demo.html', {
'ret': new_result,
"menu": "submenu1"
})
def SalientTermsTest(answers, terms):
scores = [0, 0, 0]
term_list = terms.lower().split(" ")
for i in range(0, 3):
wikiLinks = []
results = Query.GoogleSearch(answers[i])
links = results[0]
snippets = results[1]
for link in links:
if "wikipedia" in link:
wikiLinks.append(link)
wikiText = Query.GetWikiText(wikiLinks)
s = ""
for article in wikiText:
for a in article:
s += a
s = Preperation.SalientTerms(s)
article = ''.join(a for a in s if ord(a) > 31 and ord(a) < 126)
article = article.split(" ")
for word in article:
for term in term_list:
if term in word.lower() and len(term) > 3:
scores[i] += 1
return scores
def DailySummary():
message_lines = []
sunlight = Query.HoursOfSunlight()
message_lines.append(f'{sunlight:.1f} hours of sunlight in the last 24 hours')
temp_range = Query.TempRange()
message_lines.append(f'Temp range: {temp_range} Celcius')
Slack.SendMessage(message='\n'.join(message_lines))
class SchoolYear:
def __init__(self, master, main_window):
self.master = master
self.main_window = main_window
self.schoolYear = SchoolYearGUI(self.master)
self.db = Query()
self.schoolYear.back_btn.configure(command=self.back_function)
self.schoolYear.addSY_btn.configure(
command=self.addSchoolYear_function)
def addSchoolYear_function(self):
self.get_sy = self.schoolYear.newSY_var.get()
if self.get_sy == "":
return messagebox.showerror("Error",
"School year field cannot be empty")
self.reply = messagebox.askquestion("Add school year", "Are you sure?")
if self.reply.lower() == "yes":
self.db.insert_schoolyear(self.get_sy)
messagebox.showinfo("", "Success")
self.schoolYear.newSY_var.set("")
def back_function(self):
self.master.destroy()
self.main_window.deiconify()
def CSV_Writer(cursor, Time):
dr = "C:/Users/sai11/OneDrive/デスクトップ/春休み/WebScrapingProgram/Disney_Congestion_Forecast_Program/TDL_TDS_Wait_Time_List/"
Date = time.strftime("%Y_%m_%d", Time)
print(Date)
data = {}
datas = {}
now = []
cursor.execute(Query.Sel_FacID_Only())
rows = cursor.fetchall()
for row in rows:
data.setdefault(row[0])
print(data)
cursor.execute(Query.Sel_All())
rows = cursor.fetchall()
row = rows[00000]
print(row[2].hour)
now = [row[2].hour, row[2].minute]
print(now)
for row in rows:
if now[0] != row[2].hour or now[1] < row[2].minute:
print(data)
datas.setdefault(str(now[0]) + ':' + str(now[1]))
datas[str(now[0]) + ':' + str(now[1])] = copy.deepcopy(data)
now = [row[2].hour, row[2].minute]
else:
data[row[0]] = row[1]
df = pd.DataFrame(datas)
df.sort_index(axis=0, ascending=True, inplace=True)
print(df)
df.T.to_csv(dr + Date + '.csv')
def LoadWord2VecModel(self):
if self._word2VecTrainedModelPath is not None:
self._query = Query()
# self._query.LoadModel(self._word2VecTrainedModelPath)
self._query.LoadBinModel()
else:
raise ValueError('The path to model is not set yet.')
def getRackById(request):
id = request.REQUEST.get('id', None)
result = {}
if id is None or id == 0:
return HttpResponse(json.dumps(result),
content_type="application/json")
key_list = [
'id', 'idc_name', 'rack_number', 'start_time', 'end_time',
'service_provider'
]
idc = rackmodel()
r = idc.find({"id": id})
result = Query.fSqlResult(r, key_list)
key_list_1 = ['id', 'service_provider_name']
srv = servicemodel()
r_1 = srv.find({})
servers = Query.fSqlResult(r_1, key_list_1)
ret = {'result': result[0], 'sel': servers}
return HttpResponse(json.dumps(ret), content_type="application/json")
def LoadWord2VecModel(self):
if self._word2VecTrainedModelPath is not None:
self._query = Query()
self._query.LoadBinModel(self._word2VecTrainedModelPath)
else:
self._word2VecTrainedModelPath = r'C:\Users\dst\Source\Repos\WorkflowPatternFinder\WorkflowPatternFinder\Gensim\datasets\sonar-320.bin'
# raise ValueError('The path to model is not set yet.')
self.LoadWord2VecModel()
class Subjects:
def __init__(self, master, main_window):
self.master = master
self.main_window = main_window
self.subject_list = []
self.subjects = SubjectsGUI(self.master)
self.db = Query()
self.subjects.back_btn.configure(command=self.back_function)
self.subjects.addSubject_btn.configure(command=self.add_subject)
self.subjects.submit_btn.configure(command=self.submit_function)
def submit_function(self):
self.get_grade = self.subjects.grade_var.get()
if self.get_grade == "":
return messagebox.showerror("Error",
"Grade field must not be empty")
if self.subject_list == []:
return messagebox.showerror("Error", "No subject")
self.reply = messagebox.askquestion("Submit", "Are you sure?")
if self.reply.lower() == "yes":
self.db.insert_subject(self.get_grade, self.subject_list)
messagebox.showinfo("", "Success")
self.subjects.grade_var.set("")
self.subjects.subject_treeview.delete(
*self.subjects.subject_treeview.get_children())
self.subject_list = []
def add_subject(self):
self.get_subject = self.subjects.subject_var.get()
self.get_duration = self.subjects.duration_var.get()
if self.get_subject == "" or self.get_duration == "":
return messagebox.showerror("Error", "Field cannot be blank")
if self.get_duration.isalpha():
return messagebox.showerror(
"Error", "Duration must be a number of minutes")
self.subject_list.append([self.get_subject, self.get_duration])
self.subjects.subject_treeview.insert("",
"end",
values=(self.get_subject,
self.get_duration))
self.subjects.subject_var.set("")
self.subjects.duration_var.set("")
def back_function(self):
self.master.destroy()
self.main_window.deiconify()
class Rooms:
def __init__(self, master, main_window):
self.master = master
self.main_window = main_window
self.grade_list = []
self.rooms = RoomsGUI(self.master)
self.db = Query()
self.rooms.back_btn.configure(command=self.back_function)
self.rooms.add_btn.configure(command=self.add_grade)
self.rooms.addRoom_btn.configure(command=self.addRoom_function)
def add_grade(self):
self.get_grade = self.rooms.grade_var.get()
if self.get_grade == "":
return messagebox.showerror("Error", "Grade field cannot be empty")
self.grade_list.append(self.get_grade)
self.rooms.grade_treeview.insert("", "end", values=(self.get_grade))
self.rooms.grade_var.set("")
def addRoom_function(self):
self.get_roomname = self.rooms.roomName_var.get()
self.get_lab = self.rooms.lab_var.get()
if self.get_roomname == "":
return messagebox.showerror("Error",
"Room name field cannot be empty")
if self.get_lab == 0:
self.get_lab = "No"
else:
self.get_lab = "Yes"
if self.grade_list == []:
return messagebox.showerror("Error", "Grade is empty")
self.reply = messagebox.askquestion("Add room", "Are you sure?")
if self.reply.lower() == "yes":
self.db.insert_room(self.get_roomname, self.get_lab,
self.grade_list)
messagebox.showinfo("", "Success")
self.rooms.roomName_var.set("")
self.rooms.lab_var.set(0)
self.rooms.grade_var.set("")
self.rooms.grade_treeview.delete(
*self.rooms.grade_treeview.get_children())
self.grade_list = []
def back_function(self):
self.master.destroy()
self.main_window.deiconify()
def __init__(self, master, main_window):
self.master = master
self.main_window = main_window
self.schoolYear = SchoolYearGUI(self.master)
self.db = Query()
self.schoolYear.back_btn.configure(command=self.back_function)
self.schoolYear.addSY_btn.configure(
command=self.addSchoolYear_function)
def saveData(clientdata):
client_user = clientdata['user']
client_time = clientdata['time'] # NOT USED
client_lat = clientdata['lat']
client_long = clientdata['long']
client_sensor = clientdata['sensor']
client_value = clientdata['value']
# TODO: Database and logic stuff
m = mgrs.MGRS()
mgrs_coord = m.toMGRS(client_lat, client_long)
queryObj = Query()
if client_sensor == TYPE_WIFI:
bssid, ssid, strength = client_value.split(",")
if not bssid.startswith("00:00:00:00"): # No wifi connected
queryObj.insertInAllWifiData(client_user, ssid, client_lat, client_long, mgrs_coord, bssid, strength, italytimestamp())
elif client_sensor == TYPE_TEL:
tech, strength, operator, throughput = client_value.split(",")
queryObj.insertInAllTelData(client_user, client_lat, client_long, mgrs_coord, italytimestamp(), strength, operator, tech, throughput)
else:
queryObj.insertInAllSensorData(client_user, client_sensor, client_lat, client_long, mgrs_coord, client_value, italytimestamp())
queryObj.close()
def generatestates(userbuffer, topickey, schoolkey):
logging.error("entered g")
statesgen = []
numoftype = userbuffer.typeCache.getlength()
for questiontype in range(0, numoftype):
surmiselist = userbuffer.surmiseRelation.getstates(questiontype)
for surmisestate in surmiselist:
tobeaddedlist = []
tobeaddedlist.append(surmisestate)
for state in statesgen:
tobeaddedlist.append(surmisestate.union(state))
for stateadd in tobeaddedlist:
if stateadd not in statesgen:
statesgen.append(stateadd)
stateall = set()
num = numoftype - 1
while num >= 0:
stateall.add(num)
logging.error(userbuffer.typeCache.gettype(num))
num -= 1
logging.error(stateall)
if stateall not in statesgen:
statesgen.append(stateall)
tobeaddedlist = []
queryreadydict = {}
statenum = 0
for stateset in statesgen:
templist = []
for items in stateset:
templist.append(userbuffer.typeCache.gettypekey(items))
queryreadydict[statenum] = templist
statenum += 1
session = get_current_session()
logging.error(queryreadydict)
#user_name = User.query((User.username == 'Vijay_Mehta')).get()
teacher = Teacher.query(Teacher.username == 'Vijay_Mehta',
ancestor=schoolkey).get()
logging.info('@@@@@@@@@@@@@@@@@@@@@@' + str(teacher))
#Query.map_state_to_questions_dummy(queryreadydict,session['schoolkey'])
Query.map_state_to_questions(topickey, queryreadydict, schoolkey)
count = topickey.get().assessment_count
count += 1
class_v = (teacher.classes_under_teacher)[0]
#teacher=UserInfo.query()
assessment1 = Query.addAssessment(name="Know Your Numbers : " + str(count),
list_topic_key=[topickey, topickey],
school_key=schoolkey,
date=datetime.datetime.now(),
due_date=datetime.datetime(
int(2014), int(11), int(12), int(23),
int(12), int(8)),
published=True,
teacher_key=teacher.key,
class_key=class_v)
a = Query.get_states_of_topic(topickey)
def __init__(self, master, main_window):
self.master = master
self.main_window = main_window
self.subject_list = []
self.subjects = SubjectsGUI(self.master)
self.db = Query()
self.subjects.back_btn.configure(command=self.back_function)
self.subjects.addSubject_btn.configure(command=self.add_subject)
self.subjects.submit_btn.configure(command=self.submit_function)
def __init__(self, master, main_window):
self.master = master
self.main_window = main_window
self.grade_list = []
self.rooms = RoomsGUI(self.master)
self.db = Query()
self.rooms.back_btn.configure(command=self.back_function)
self.rooms.add_btn.configure(command=self.add_grade)
self.rooms.addRoom_btn.configure(command=self.addRoom_function)
def add_source(self, data, kind):
if SourceType.query == kind:
query = Query(text=data, features=self.features)
query.analysis = self.analyze_source(source=query)
self.queries.append(query)
elif SourceType.document == kind:
document = Document(text=data, features=self.features)
document.analysis = self.analyze_source(source=document)
document.document_id = len(self.documents)
self.documents.append(document)
def restaurants_handler():
if lockAPI:
destination = request.args.get('dest', default="JFK", type=str)
return json.jsonify(
Query.run_yelp_query(
Query.searchQuery(location=destination))["data"]["search"])
destination = request.args.get('dest', default="JFK", type=str)
cityInfo = Query.runLocationQuery(destination, ["cityname"])
return json.jsonify(
Query.run_yelp_query(
Query.searchQuery(location=cityInfo[0]))["data"]["search"])
def nass_chem_input_data(filename):
"""Query NASS quickstats for chemical input amounts and save to filename"""
nass = Query.QueryNASS("key.txt")
# Start by grabbing all the environmental sector data
env = nass.query(state_alpha="=OR", sector_desc="=ENVIRONMENTAL")
# limit to amount of chemical inputs
chems = env[env.unit_desc == "LB"]
# clean it up
chems = Query.scrub_missing_data(chems)
# save this for later
Query.write_data(chems, "data/ChemicalInputAmounts.csv")
return chems
def flights():
if lockAPI:
return json.jsonify(Query.postProcessFlights(flightData))
# TODO: TO LIMIT API USAGE, FOLLOWING HAS BEEN COMMENTED OUT
origin = request.args.get('origin', default="ATL", type=str)
destination = request.args.get('dest', default="JFK", type=str)
oneWeek = datetime.date.today() + datetime.timedelta(days=7)
departDate = request.args.get('departDate', default=str(oneWeek), type=str)
endDate = request.args.get('endDate', default=str(oneWeek), type=str)
json_response = Query.runFlightsQuery(origin, destination, departDate,
endDate)
return json.jsonify(Query.postProcessFlights(json_response))
def __init__(self, master, main_window):
self.master = master
self.main_window = main_window
self.grade_list = []
self.subject_list = []
self.teachers = TeachersGUI(self.master)
self.db = Query()
self.teachers.back_btn.configure(command=self.back_function)
self.teachers.addGrade_btn.configure(command=self.add_grade)
self.teachers.addSubject_btn.configure(command=self.add_subject)
self.teachers.subject_box.bind("<Button-1>", self.subjectBox_function)
self.teachers.addTeacher_btn.configure(command=self.add_teacher)
def getpendingassessment(request):
session = get_current_session()
studentkey = session.get('studentkey',-1)
subjectlist = Query.get_subjects_by_student(studentkey)
pendingassessmentbysubject = {}
for subject in subjectlist:
pendingassessments = Query.get_pending_assessments_by_subject(studentkey,subject.key)
logging.error(pendingassessments)
pendingassessmentbysubject[subject.name]= pendingassessments
t = loader.get_template('Dashboard/pending_assessments.xml')
c = Context({'assessmentdict':pendingassessmentbysubject,})
return HttpResponse(t.render(c),
content_type="text/xml")
def match_friends(json_result, layer):
#Arrays are less data intensive and easier to use
arr = []
edge_layer = Q.json_subset(json_result, layer)[layer]
#edge should be a dict
for edge in edge_layer:
#TODO: get rid of hard coding
i_d = Q.json_extract(edge, "p_id")[0]
following = Q.json_extract(edge, "following_id")
followers = Q.json_extract(edge, "follower_id")
arr.append([i_d,following,followers])
return pd.DataFrame(data=arr,
columns=("id","following","followers")).set_index("id")
def hc_create(submenu4,mycursor, top, mydb):
submenu4.add_command(label=('Mask',), command=lambda : Query.wait('healthcare',1,mycursor, top, mydb))
submenu4.add_separator()
submenu4.add_command(label=('Sanitizer',), command=lambda : Query.wait('healthcare',2,mycursor, top, mydb))
submenu4.add_separator()
submenu4.add_command(label=('Disinfectant',), command=lambda : Query.wait('healthcare',3,mycursor, top, mydb))
submenu4.add_separator()
submenu4.add_command(label=('FaceShield',), command=lambda : Query.wait('healthcare',4,mycursor, top, mydb))
submenu4.add_separator()
submenu4.add_command(label=('Gloves',), command=lambda : Query.wait('healthcare',5,mycursor, top, mydb))
submenu4.add_separator()
def veggie_create(submenu3,mycursor, top, mydb):
submenu3.add_command(label=('Carrot',), command=lambda : Query.wait('vegetables',1,mycursor, top, mydb))
submenu3.add_separator()
submenu3.add_command(label=('Raddish',), command=lambda : Query.wait('vegetables',2,mycursor, top, mydb))
submenu3.add_separator()
submenu3.add_command(label=('Potato',), command=lambda : Query.wait('vegetables',3,mycursor, top, mydb))
submenu3.add_separator()
submenu3.add_command(label=('Onion',), command=lambda : Query.wait('vegetables',4,mycursor, top, mydb))
submenu3.add_separator()
submenu3.add_command(label=('Pumpkin',), command=lambda : Query.wait('vegetables',5,mycursor, top, mydb))
submenu3.add_separator()
def fruit_create(submenu2,mycursor, top, mydb):
submenu2.add_command(label=('Mango',), command=lambda : Query.wait('fruits',1,mycursor, top, mydb))
submenu2.add_separator()
submenu2.add_command(label=('Grapes',), command=lambda : Query.wait('fruits',2,mycursor, top, mydb))
submenu2.add_separator()
submenu2.add_command(label=('Apple',), command=lambda : Query.wait('fruits',3,mycursor, top, mydb))
submenu2.add_separator()
submenu2.add_command(label=('Pineapple',), command=lambda : Query.wait('fruits',4,mycursor, top, mydb))
submenu2.add_separator()
submenu2.add_command(label=('Lichi',), command=lambda : Query.wait('fruits',5,mycursor, top, mydb))
submenu2.add_separator()
def mp_create(submenu1,mycursor, top, mydb):
submenu1.add_command(label=('Milk',), command=lambda : Query.wait('milkproducts',1,mycursor, top, mydb))
submenu1.add_separator()
submenu1.add_command(label=('Cheese',), command=lambda : Query.wait('milkproducts',2,mycursor, top, mydb))
submenu1.add_separator()
submenu1.add_command(label=('Paneer',), command=lambda : Query.wait('milkproducts',3,mycursor, top, mydb))
submenu1.add_separator()
submenu1.add_command(label=('MilkPowder',), command=lambda : Query.wait('milkproducts',4,mycursor, top, mydb))
submenu1.add_separator()
submenu1.add_command(label=('Curd',), command=lambda : Query.wait('milkproducts',5,mycursor, top, mydb))
submenu1.add_separator()
def groc_create(submenu,mycursor, top, mydb):
submenu.add_command(label=('salt',), command=lambda : Query.wait('groceries',1,mycursor, top, mydb))
submenu.add_separator()
submenu.add_command(label=('sugar',), command=lambda : Query.wait('groceries',2,mycursor, top, mydb))
submenu.add_separator()
submenu.add_command(label=('Wheat',), command=lambda : Query.wait('groceries',3,mycursor, top, mydb))
submenu.add_separator()
submenu.add_command(label=('Rice',), command=lambda : Query.wait('groceries',4,mycursor, top, mydb))
submenu.add_separator()
submenu.add_command(label=('Chilli',), command=lambda : Query.wait('groceries',5,mycursor, top, mydb))
submenu.add_separator()
def getServerById(request):
id = request.REQUEST.get('id', None)
result = {}
if id is None or id == 0:
return HttpResponse(json.dumps(result),
content_type="application/json")
key_list = [
'id', 'hostname', 'manage_ip', 'other_ip', 'app_name',
'system_version', 'zabbix_template', 'owner_group', 'server_type',
'cpu', 'mem', 'disk', 'sn', 'an', 'units', 'idc_name', 'rack_number',
'rack_units', 'create_date', 'end_date', 'switch_name', 'switch_port',
'change_time', 'change_dev_info', 'change_people', 'description',
'status'
]
# sql = Sql.get_s_sql('server', key_list, {"id": id})
sv = servermodel()
r = sv.find({"id": id})
result = Query.fSqlResult(r, key_list)
key_list = ['id', 'room_name']
# sql = Sql.get_s_sql('room', key_list, {})
rm = roommodel()
r = rm.find({})
room = Query.fSqlResult(r, key_list)
key_list_1 = ['id', 'idc_name']
# sql_1 = Sql.get_s_sql('idc', key_list_1, {})
rk = rackmodel()
r = rk.find({})
idc = Query.fSqlResult(r_1, key_list_1)
key_list_2 = ['id', 'device_name']
# sql_2 = Sql.get_s_sql('network_config', key_list_2, {})
nw = networkingmodel()
r_2 = nw.find({})
network = Query.fSqlResult(r_2, key_list_2)
ret = {
'result': result[0],
'idc': idc,
'room': room,
'owner_group': ServerGroup.group,
'server_type': ServerGroup.type,
'network': network
}
print "ret=" + str(ret)
return HttpResponse(json.dumps(ret), content_type="application/json")
def rack_list(request):
page = request.REQUEST.get('p', 1)
pageSize = request.REQUEST.get('pageSize', 6)
key_list = [
'id', 'idc_name', 'rack_number', 'start_time', 'end_time',
'service_provider'
]
rk = rackmodel()
r = rk.find({})
result = Query.fSqlResult(r, key_list)
totalPage = rk.count({})
print "totalPage2=" + str(totalPage)
if totalPage % pageSize:
totalPage = totalPage / pageSize + 1
else:
totalPage = totalPage / pageSize
key_list_1 = ['id', 'service_provider_name']
svr = servicemodel()
r_1 = svr.find({})
servers = Query.fSqlResult(r_1, key_list_1)
new_service = {}
for srv in servers:
for id in srv:
print id
if id == 'id':
new_service[srv[id]] = srv['service_provider_name']
new_result = []
for item in result:
if new_service.has_key(item['service_provider']):
item['service_provider'] = new_service[item['service_provider']]
item['start_time'] = UserTime.utcToString(float(item['start_time']))
item['end_time'] = UserTime.utcToString(float(item['end_time']))
new_result.append(item)
return render(
request, 'rack/rack_list.html', {
'ret': result,
'totalpage': totalPage,
'current': page,
'lastPage': totalPage
})
def query(self, query):
if isinstance(query, str):
query = Query(query = query)
if query.finished:
rospy.wait_for_service(self.prologQueryService)
request = rospy.ServiceProxy(self.prologQueryService, PrologQuery)
try:
response = request(id = str(query.id), query = str(query))
query.client = self
except rospy.ServiceException, exception:
raise Exception("PrologQuery service request failed: %s" % exception)
if not response.ok:
raise Exception("Prolog query failed: %s" % response.message)
def start_search(self):
# print(self.type.get())
if self.type.get() == 1:
self.top_results.delete(1.0, END)
# OUTPUT to file called output.txt
sys.stdout = open("output2.txt", "w")
i = html_parse.InvertedIndex()
i.html_parse()
i.calculate_all_tf_idf()
i.write_inverted_ind()
i.write_total_docs()
i.write_doc_length()
elif self.type.get() == 2:
self.top_results.delete(1.0, END)
query = Query.Query(self.search_input.get())
self.top_results.configure(state="normal")
i = 1
for q in query.run_query_gui():
self.top_results.insert(END, str(i) + ". " + q + '\n\n')
i += 1
self.top_results.configure(state="disabled")
self.type.set(0)
def getspecialcourses(request):
session = get_current_session()
schoolkey=session.get('schoolkey',-1)
specialcourseslist=Query.get_global_subjects(schoolkey)
t = loader.get_template('Dashboard/globalcourseslist.xml')
c = Context({'specialcourses':specialcourseslist,})
return HttpResponse(t.render(c),
content_type="text/xml")
def main():
"""Print the top 20 chemical inputs by weight used in Oregon agriculture"""
nass = Query.QueryNASS("key.txt")
# Start by grabbing all the environmental sector data
env = nass.query(state_alpha="=OR", sector_desc="=ENVIRONMENTAL")
# limit to amount of chemical inputs
chems = env[env.unit_desc == "LB"]
# save this for later
Query.write_data(chems, "data/ChemicalInputAmounts.csv")
# clean it up
chems = Query.scrub_missing_data(chems)
# groupby input to find the chemical with largest cumulative application
# over all years, crops, and locations for which there is data
cumchems = chems.groupby("domaincat_desc").sum()
print("domain category weight of chemical applied (lb)")
print(cumchems.Value.sort(inplace=False, na_position="first").tail(20))
return
def mastery_by_student_by_class(request):
session = get_current_session()
teacherkey = session.get('teacherkey',-1)
mastery_by_student = Query.get_mastery_by_student_of_class(teacherkey)
t = loader.get_template('Dashboard/teacher_mastery_by_student')
c = Context({'mastery_by_student':mastery_by_student ,})
return HttpResponse(t.render(c),content_type="text/xml")
def subjectdetailsofstudent(request):
session = get_current_session()
type =session.get('type',-1)
if type == Constant.Constant.STUDENT:
subjectdetails = Query.get_subject_details_by_student(session['studentkey'])
t = loader.get_template('Dashboard/subjectdetailsofstudent')
c = Context({'subjectdetails':subjectdetails,})
return HttpResponse(t.render(c),content_type="text/xml")
def getmasterybysubject(request):
session = get_current_session()
studentkey = session.get('studentkey',-1)
mastery = Query.get_mastery_for_all_subjects(studentkey)
t = loader.get_template('Dashboard/average_mastery_by_subject.xml')
c = Context({'masterdict':mastery,})
return HttpResponse(t.render(c),
content_type="text/xml")
def get_not_recently_loggedin_all(request):
session = get_current_session()
teacherkey = session.get('teacherkey',-1)
notrecentlyloggedin = Query.get_students_not_logged_in_of_all_class(teacherkey)
logging.error(notrecentlyloggedin)
t = loader.get_template('Dashboard/not_recently_logged_in_all')
c = Context({'notrecentlyloginall': notrecentlyloggedin,})
return HttpResponse(t.render(c),content_type="text/xml")
def getcourseinformation(request):
key = request.GET['id']
subjectkey = ndb.Key(urlsafe=key)
courseinformation=Query.get_course_detail_by_subject(subjectkey)
t = loader.get_template('Dashboard/getcourseinformation.xml')
c = Context({'total_students':courseinformation['Total_Students'],'number_completed':courseinformation['100_Score_Students'],'average_score':courseinformation['Average_Score']})
return HttpResponse(t.render(c),
content_type="text/xml")
def getaveragemasterybysubjectallclass(request):
session = get_current_session()
teacherkey = session.get('teacherkey',-1)
averagemasterybysubject = Query.get_average_mastery_by_subject_of_all_class(teacherkey)
logging.error(averagemasterybysubject)
t = loader.get_template('Dashboard/averagemasterybysubject_allclass.xml')
c = Context({'averagemasterydict': averagemasterybysubject,})
return HttpResponse(t.render(c),content_type="text/xml")
def get_classes_of_teacher(request):
session = get_current_session()
teacherkey = session.get('teacherkey',-1)
classdetails = Query.get_class_details_of_teacher(teacherkey)
t = loader.get_template('Dashboard/getclassdetails_byteacher')
c = Context({'getclassdetailsdict': classdetails,})
return HttpResponse(t.render(c),content_type="text/xml")
def generatestates(userbuffer,topickey,schoolkey):
logging.error("entered g")
statesgen =[]
numoftype = userbuffer.typeCache.getlength()
for questiontype in range(0,numoftype):
surmiselist = userbuffer.surmiseRelation.getstates(questiontype)
for surmisestate in surmiselist:
tobeaddedlist =[]
tobeaddedlist.append(surmisestate)
for state in statesgen:
tobeaddedlist.append(surmisestate.union(state))
for stateadd in tobeaddedlist:
if stateadd not in statesgen:
statesgen.append(stateadd)
stateall = set()
num = numoftype-1
while num >= 0:
stateall.add(num)
logging.error(userbuffer.typeCache.gettype(num))
num-=1
logging.error(stateall)
if stateall not in statesgen:
statesgen.append(stateall)
tobeaddedlist=[]
queryreadydict = {}
statenum =0
for stateset in statesgen:
templist = []
for items in stateset:
templist.append(userbuffer.typeCache.gettypekey(items))
queryreadydict[statenum]=templist
statenum+=1
session = get_current_session()
logging.error(queryreadydict)
#user_name = User.query((User.username == 'Vijay_Mehta')).get()
teacher = Teacher.query(Teacher.username == 'Vijay_Mehta',ancestor=schoolkey).get()
logging.info('@@@@@@@@@@@@@@@@@@@@@@'+str(teacher))
#Query.map_state_to_questions_dummy(queryreadydict,session['schoolkey'])
Query.map_state_to_questions(topickey,queryreadydict,schoolkey)
count=topickey.get().assessment_count
count+=1
class_v=(teacher.classes_under_teacher)[0]
#teacher=UserInfo.query()
assessment1=Query.addAssessment(name="Know Your Numbers : "+str(count),list_topic_key=[topickey,topickey],school_key=schoolkey,date=datetime.datetime.now(),due_date=datetime.datetime(int(2014),int(11),int(12),int(23),int(12),int(8)),published=True,teacher_key=teacher.key,class_key=class_v)
a=Query.get_states_of_topic(topickey)
def getreadytolearnbysubject(request):
session = get_current_session()
studentkey = session.get('studentkey',-1)
readytolearndict = Query.get_ready_to_learn_of_all_topic_dummy(studentkey)
t = loader.get_template('Dashboard/readytolearn_by_subject')
c = Context({'readytolearndict':readytolearndict,})
return HttpResponse(t.render(c),
content_type="text/xml")
def getgrowthforallsubject(request):
session = get_current_session()
studentkey = session.get('studentkey',-1)
growthdict = Query.get_growth_for_all_subject(studentkey)
t = loader.get_template('Dashboard/growth_per_subject.xml')
c = Context({'growthdict':growthdict,})
return HttpResponse(t.render(c),
content_type="text/xml")
def getaveragemasterybysubjectallsubject(request):
session = get_current_session()
teacherkey = session.get('teacherkey',-1)
key = request.GET['id']
classkey = ndb.Key(urlsafe=key)
averagemasterybysubject = Query.get_average_mastery_all_subject_detailed(teacherkey,classkey)
logging.error(averagemasterybysubject)
t = loader.get_template('Dashboard/averagemasterybysubject_allsubject')
c = Context({'averagemasterydict': averagemasterybysubject,})
return HttpResponse(t.render(c),content_type="text/xml")
def gettopicwisescoreofsubject(request):
session = get_current_session()
studentkey = session.get('studentkey',-1)
key = request.GET['id']
subjectkey = ndb.Key(urlsafe=key)
topicwisescore=Query.get_recent_assessment_topic_scores_of_student(studentkey,subjectkey)
t = loader.get_template('Dashboard/course_statistics.xml')
c = Context({'topicwisescore':topicwisescore,})
return HttpResponse(t.render(c),
content_type="text/xml")
def get_assessment_coverage_of_class(request):
session = get_current_session()
teacherkey = session.get('teacherkey',-1)
key = request.GET['id']
classkey = ndb.Key(urlsafe=key)
assessmentcoveragedict = Query.get_assessment_coverage_of_class(teacherkey,classkey)
logging.error("&&&&&&&&&&&&&&&&&&777"+str(assessmentcoveragedict))
t = loader.get_template('Dashboard/assessmentcoveragebyclass')
c = Context({'assessmentcoveragedict': assessmentcoveragedict,})
return HttpResponse(t.render(c),content_type="text/xml")
def getreadytolearnofsubject(request):
session = get_current_session()
studentkey = session.get('studentkey',-1)
key = request.GET['id']
subjectkey = ndb.Key(urlsafe=key)
readytolearnofsubject=Query.get_recent_assessment_next_type_url_of_student(studentkey,subjectkey)
t = loader.get_template('Dashboard/readytolearn_ofsubject')
c = Context({'readytolearnofsubject':readytolearnofsubject,})
return HttpResponse(t.render(c),
content_type="text/xml")
def get_students_not_logged_in_by_class(request):
session = get_current_session()
teacherkey = session.get('teacherkey',-1)
key = request.GET['id']
classkey = ndb.Key(urlsafe=key)
notrecentlyloggedin = Query.get_students_not_logged_in_by_class(teacherkey,classkey)
t = loader.get_template('Dashboard/notrecentlyloggedin_byclass')
c = Context({'notrecentlyloggedinbyclass': notrecentlyloggedin,})
return HttpResponse(t.render(c),content_type="text/xml")
def get_subject_of_class(request):
session = get_current_session()
teacherkey = session.get('teacherkey',-1)
key = request.GET['id']
classkey = ndb.Key(urlsafe=key)
logging.error(classkey)
subjectdict = Query.get_subject_details_of_teacher_in_class(teacherkey,classkey)
t = loader.get_template('Dashboard/getsubjectofclass')
c = Context({'getsubjectofclass': subjectdict,})
return HttpResponse(t.render(c),content_type="text/xml")
def initializebuffer(self,topickey):
types_db = topickey.get().types
question_db = Query.get_a_question_of_each_type(topickey)
state_db =Query.get_states_of_topic(topickey)
self.numstates=len(state_db)
type(state_db)
initialprob = 1/float(len(state_db) + 1)
previous_minquestion=-1
#preparing questions dictionary which will be asked during assessment
for temptype in types_db:
t=Query.get_state_count_of_types(topickey)
logging.error(t)
num_states = Query.get_state_count_of_types(topickey)[temptype]
logging.error(t)
tempqueskey=question_db[temptype]
tempques=tempqueskey.get()
questionstring=tempques.instance.problem_statement
answer = tempques.instance.answer
url = tempques.instance.url
if previous_minquestion==-1:
previous_minquestion = abs(int(((len(state_db)+1)/2)-num_states)) #if numberofstates in which this question is closest to 50 percent
self.minquestion=tempques.key #minquestion will be the first question to ask
else:
if(abs(int((len(state_db)+1)/2)-num_states) < previous_minquestion):
previous_minquestion = abs(int(((len(state_db)+1)/2)-num_states))
self.minquestion = tempques.key #minquestion will be the first question to ask
self.questions[tempques.key]=Question(tempques.key,temptype,num_states,initialprob*num_states,questionstring,answer,url)
self.states[0] =[State((-1,),initialprob,0)]
for tempstate in state_db:
types_in_state = Query.get_types_of_state(tempstate.key)
#questions = Query.get_questions_of_state(tempstate.key)
queskeylist =[]
for types in types_in_state:
questionkey=question_db[types]
queskeylist.append(questionkey)
questiontuple = tuple(queskeylist)
key=tempstate.key
size = len(questiontuple)
temp = self.states.get(size)
if temp is None:
self.states[size]=[]
self.states[size].append(State(questiontuple,initialprob,key))
def getlearningprogressdatewise(request):
session = get_current_session()
studentkey = session.get('studentkey',-1)
key = request.GET['id']
subjectkey = ndb.Key(urlsafe=key)
learningprogressdict = Query.get_learning_progress_date_wise_dummy(studentkey,subjectkey)
t = loader.get_template('Dashboard/learningprogress_by_date')
c = Context({'learningprogressdict':learningprogressdict,})
return HttpResponse(t.render(c),
content_type="text/xml")
def get_readytolearn_of_subject(request):
session = get_current_session()
teacherkey = session.get('teacherkey',-1)
key = request.GET['classid']
classkey = ndb.Key(urlsafe=key)
key = request.GET['subjectid']
subjectkey = ndb.Key(urlsafe=key)
logging.error("99999999999999999999999999999999")
readytolearn = Query.get_ready_to_learn_of_class(teacherkey,classkey,subjectkey)
t = loader.get_template('Dashboard/readytolearn_ofsubjectofclass')
c = Context({'readytolearndict': readytolearn,})
return HttpResponse(t.render(c),content_type="text/xml")
def get_averagemastery_of_subject_topicwise(request):
session = get_current_session()
teacherkey = session.get('teacherkey',-1)
key = request.GET['classid']
classkey = ndb.Key(urlsafe=key)
key = request.GET['subjectid']
subjectkey = ndb.Key(urlsafe=key)
averagemasteryofsubject = Query.get_average_mastery_of_a_subject(teacherkey,classkey,subjectkey)
logging.error(averagemasteryofsubject)
t = loader.get_template('Dashboard/averagemasteryofsubjecttopicwise')
c = Context({'averagemasterydict': averagemasteryofsubject,})
return HttpResponse(t.render(c),content_type="text/xml")
def getmasteryofsubject(request):
session = get_current_session()
studentkey = session.get('studentkey',-1)
logging.error("ank")
logging.error(studentkey)
key = request.GET['id']
subjectkey = ndb.Key(urlsafe=key)
mastery=Query.get_recent_assessment_score_of_student(studentkey,subjectkey)
t = loader.get_template('Dashboard/donut_mastery.xml')
c = Context({'mastery':mastery,})
return HttpResponse(t.render(c),
content_type="text/xml")
def getgrowthofsubject(request):
session = get_current_session()
studentkey = session.get('studentkey',-1)
logging.error("ank")
logging.error(studentkey)
key = request.GET['id']
subjectkey = ndb.Key(urlsafe=key)
growthdict=Query.get_learning_progress(studentkey,subjectkey)
t = loader.get_template('Dashboard/subject_learning_growth.xml')
c = Context({'growth':growthdict,})
return HttpResponse(t.render(c),
content_type="text/xml")
def getRadiusAndTimeoutForClient(cuser, csensor, cmgrs):
# Index field in DB rows
fMGRS, fGRANULARITY, fTIMEOUT, fGRANSAMPLE = 3, 4, 7, 9
fStakeID = 2
# Getting rules
queryObj = Query()
# JUST USE stakeholders_rules, redundant and problem with field number!
rules = []
#rules = list(queryObj.getAllRulesForSensor(csensor))
stakeholders_accepted = list( map( lambda x:x[fStakeID], list(queryObj.getSubscriptionByUserAndSensor(cuser, csensor)) ))
rules_stakeholders = []
for s in stakeholders_accepted:
rules_stakeholders += list(queryObj.getAllStakeholdersRulesForSensor(csensor, s))
rules += rules_stakeholders
queryObj.close()
# Use of fGRANULARITY here to check belonging
# belongs = list(filter(lambda r:belongsto(r[fMGRS], cmgrs, r[fGRANULARITY]), rules))
belongs = list(filter(lambda r:belongsto(r[fMGRS], cmgrs, r[fGRANSAMPLE]), rules))
#print(belongs)
if belongs:
# Radius from max granularity or default
finest = max(belongs, key=lambda x:x[fGRANSAMPLE])
c_lat, c_long = getCenterOfMGRSInCoord(finest[fMGRS], finest[fGRANSAMPLE])
radius = granToRadius[finest[fGRANSAMPLE]]
# Timeout from min sampled
samplest = min(belongs, key=lambda x:x[fTIMEOUT])
timeout = samplest[fTIMEOUT]
else:
c_lat, c_long = None, None
radius, timeout = DEFAULT_RADIUS, DEFAULT_TIMEOUT
return (c_lat, c_long, radius, timeout)
def __init__(self,topickey):
self.typeCache = TypeCache()
question_db = Query.get_questions_of_topic(topickey)
typeid=-1
for tempques in question_db:
typeid+=1
questionstring=tempques.instance.problem_statement
key = tempques.key
self.typeCache.addtype(key,typeid,questionstring)
self.surmiseRelation = SurmiseRelation(self)
self.blockCache = BlockCache()
self.blockCache = BlockCache()
def dashboard(request):
session = get_current_session()
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
user_information= Query.login(username,password)
logging.error(user_information)
if user_information < 0:
return render_to_response('Gen_templates/template_login.html',{'invalid_message': "Enter Correct Credentials"},context_instance = RequestContext(request))
session['type'] = user_information[0]
if session['type'] == Constant.Constant.STUDENT:
student = user_information[1]
session['studentkey']= student.key
session['schoolkey']=student.school
session['studentname']=student.basic_info.firstname + student.basic_info.lastname
session['email'] = student.basic_info.email
session['studentaddress']= student.basic_info.address
session['contactnumber'] = student.basic_info.contact_no
session['dateofbirth '] =student.basic_info.date_of_birth
session['sex']=student.basic_info.sex
session['lastlogin']=user_information[2]
return render_to_response('Dashboard/dashboard.html',{ },context_instance = RequestContext(request))
if session['type'] == Constant.Constant.TEACHER:
teacher = user_information[1]
session['teacherkey']=teacher.key
session['schoolkey']=teacher.school
session['teachername']=teacher.basic_info.firstname + teacher.basic_info.lastname
session['email'] = teacher.basic_info.email
session['teacheraddress']= teacher.basic_info.address
session['contactnumber'] = teacher.basic_info.contact_no
session['dateofbirth '] = teacher.basic_info.date_of_birth
session['sex']=teacher.basic_info.sex
session['lastlogin']=user_information[2]
return render_to_response('Dashboard/teacherdashboard.html',{},context_instance = RequestContext(request))
return render_to_response('Gen_templates/template_login.html',{'loginurl': users.create_login_url('/'),},context_instance = RequestContext(request))
else:
if session['type'] == Constant.Constant.TEACHER:
return render_to_response('Dashboard/teacherdashboard.html',{},context_instance = RequestContext(request))
if session['type'] == Constant.Constant.STUDENT:
return render_to_response('Dashboard/dashboard.html',{},context_instance = RequestContext(request))
