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))