def test_YOSA(): # subject_input_list = [ # Subject("알고리즘", 4, 1, 0, 0), # # Subject("웹프", 3, 7, 1, 0), # # Subject("직능훈", 2, 4, 2, 0), # # Subject("알고리즘", 4, 5, 3, 1), # Subject("C++", 4, 24, 4, 1), # # Subject("웹프", 3, 3, 5, 1), # # Subject("알고리즘", 4, 4, 6, 2), # # Subject("데베설", 3, 5, 7, 2), # # Subject("운영체제", 2, 6, 8, 2), # ] subject_input_list = [ Subject("알고리즘", 1, 1, 0, 0), # Subject("웹프", 3, 7, 1, 0), # Subject("직능훈", 2, 4, 2, 0), # Subject("알고리즘", 4, 5, 3, 1), Subject("C++", 1, 23, 4, 1), # Subject("웹프", 3, 3, 5, 1), # Subject("알고리즘", 4, 4, 6, 2), # Subject("데베설", 3, 5, 7, 2), # Subject("운영체제", 2, 6, 8, 2), ] student_count = 2 # for i in range(1, 40): # yosa = YOSA(subject_input_list, student_count, i) # yosa.run() yosa = YOSA(subject_input_list, student_count, 40) yosa.run() yosa = YOSA(subject_input_list, student_count, 35) yosa.run()
def find_maxima(self, start_sol, max_time): population = [Subject(i, self.evaluation(i)) for i in start_sol] t_end = time.time() + max_time while time.time() < t_end: strongest = self.select_strongest(population) for couple in strongest: new_genom = self.crossbreed(couple[0], couple[1]) if new_genom in [p.genom for p in population]: continue population.append(Subject(new_genom, self.evaluation(new_genom)) \ if self.in_dict(new_genom) and self.can_assemble(new_genom) \ else Subject(new_genom, 0)) if len(population) > self.pop_count: population = sorted(population, key=lambda x: x.value, reverse=True)[0:self.pop_count] for e in population: print(e.genom) self.best_sol = sorted(population, key=lambda x: x.value, reverse=True)[0].genom self.best_val = self.evaluation(self.best_sol)
def main(): s = Subject() subject = s.get_subject() if not (subject == ""): send_email_proccess(subject) else: print('You should entry the subject of email')
def setUp(self): self.EPSILON = 0.01 sub1 = Subject("Biologia", [[3.5, 2.5, 5.0], [1, 1, 1, 1, 1, 1, 1, 1, 0]]) sub2 = Subject("Matematyka", [[2.5, 3.0, 2.5], [1, 1, 0, 1, 0, 1, 0, 1, 1]]) self.subjects = [sub1, sub2] self.andrzej = Student("Andrzej Abacki", self.subjects) self.diary = Diary("AGH", 2016, "data.json")
def reducer(acc, term): subj = Subject(subject_id) score = term["score"][regno][subject_id] gradings = term["gradings"] ratio = term["ratio"] grade = subj.scoreToGrade(score, gradings) acc["score"] += score * ratio acc["grade"] += grade * ratio return acc
def main(): root = Tk() subject = Subject() _views = [] for i in range(5): _views.append(Note(root, i, 'View %i' % i)) for v in _views: subject.attach(v) my_gui = MainView(root, subject) root.mainloop()
class TestSubject(TestCase): def setUp(self): self.sub1 = Subject("ZTI", [[4, 5, 5], [0, 1, 1, 1, 1]]) self.sub2 = Subject("PITE", [[4.5, 5, 5, 4], [1, 1, 1, 1, 1]]) def test_get_average1(self): self.assertAlmostEquals(self.sub1.get_average(), 14. / 3, 2) def test_get_average2(self): self.assertAlmostEquals(self.sub2.get_average(), 18.5 / 4, 2) def test_get_attendance1(self): self.assertEqual(self.sub1.get_attendance(), 80) def test_get_attendance2(self): self.assertEqual(self.sub2.get_attendance(), 100)
def assign_new_semester(self): system('cls') id_student = int(input("Enter the student's identification: ")) pos_student = self.__find_student(id_student) if pos_student != -1: name_subject = input("Enter the subject's name: ") notes = self.__load_notes() id_teacher = int(input("Enter the teacher's identification: ")) pos_teacher = self.__find_teacher(id_teacher) if pos_teacher != -1: new_subject = Subject(name_subject, notes, self.teachers[pos_teacher]) new_semester = Semestre(self.students[pos_student], new_subject) self.semestres.append(new_semester) system('cls') print("The assign was created successful") else: system('cls') print("The teacher not exists") else: print("The student not exists") input()
def update_protocols(self): """ If we change the protocol file, update the stored version in subject files """ # # get list of protocol files protocols = os.listdir(prefs.PROTOCOLDIR) protocols = [p for p in protocols if p.endswith('.json')] subjects = self.list_subjects() for subject in subjects: if subject not in self.subjects.keys(): self.subjects[subject] = Subject(subject) protocol_bool = [ self.subjects[subject].protocol_name == p.rstrip('.json') for p in protocols ] if any(protocol_bool): which_prot = np.where(protocol_bool)[0][0] protocol = protocols[which_prot] self.subjects[subject].assign_protocol( os.path.join(prefs.PROTOCOLDIR, protocol), step_n=self.subjects[subject].step) msgbox = QtGui.QMessageBox() msgbox.setText("Subject Protocols Updated") msgbox.exec_()
def add_subject(self, subject_name, start_time, is_even, day): subs = self.subjects.get(day) s = Subject(subject_name, start_time, is_even) if (subs == None): self.subjects.update({day: [s]}) else: subs.append(s)
def temp(self): filenames = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))] self.data = [] cnt = 0 for filename in filenames: if filename.startswith("."): continue print(str(cnt) + ". " + filename.split("-")[0]) cnt += 1 s = Subject() s.readData(os.path.join(path, filename)) self.data.append(s)
def __init__(self, name, service, view, data, caller): Subject.__init__(self) self.observers = [] self.name = name self.caller = caller self.temperature = Temperature(None) self.rainfall = Rainfall(None) self.timestamp = None self.datestamp = None self.serviceType = service self.viewType = view self.dataType = data self.client = None self.timer = None self.setupClient()
class TestSubject(unittest.TestCase): def setUp(self): self.code=1 self.name='aps' self.slist=None self.testobj=Subject(self.code,self.name,self.slist) def test_getSubjectName(self): print('subject name') self.assertEqual(self.testobj.getSubjectName(),self.name) def test_getSubjectCode(self): print('subject code') self.assertEqual(self.testobj.getSubjectCode(),self.code) def test_getSudentList(self): print('student list') self.assertEqual(self.testobj.getStudentList(),self.slist)
def reassign_protocols(self): """ Batch reassign protocols and steps. Opens a :class:`.gui.Reassign` window after getting protocol data, and applies any changes made in the window. """ # get list of protocol files protocols = os.listdir(prefs.PROTOCOLDIR) protocols = [ os.path.splitext(p)[0] for p in protocols if p.endswith('.json') ] # get subjects and current protocols subjects = self.list_subjects() subjects_protocols = {} for subject in subjects: if subject not in self.subjects.keys(): self.subjects[subject] = Subject(subject) subjects_protocols[subject] = [ self.subjects[subject].protocol_name, self.subjects[subject].step ] reassign_window = Reassign(subjects_protocols, protocols) reassign_window.exec_() if reassign_window.result() == 1: subject_protocols = reassign_window.subjects for subject, protocol in subject_protocols.items(): step = protocol[1] protocol = protocol[0] # since assign_protocol also changes the step, stash the step number here to tell if it's changed subject_orig_step = self.subjects[subject].step if self.subjects[subject].protocol_name != protocol: self.logger.info( 'Setting {} protocol from {} to {}'.format( subject, self.subjects[subject].protocol_name, protocol)) protocol_file = os.path.join(prefs.PROTOCOLDIR, protocol + '.json') self.subjects[subject].assign_protocol(protocol_file, step) if subject_orig_step != step: self.logger.info('Setting {} step from {} to {}'.format( subject, subject_orig_step, step)) step_name = self.subjects[subject].current[step][ 'step_name'] #update history also flushes current - aka it also actually changes the step number self.subjects[subject].update_history( 'step', step_name, step)
def parse_data(self): for row in self.__information: lesson = Lesson(row[0], row[1], row[5], row[6], row[7]) subject = Subject(row[4], row[9], lesson) student = Student(row[3], row[2], row[8], row[9], subject) if self.check_student(student): self.__student_list.append(student) else: for stud in self.__student_list: if stud.get_surname() == student.get_surname( ) and stud.get_group_code() == student.get_group_code(): stud.get_subject_list().append(subject)
def add(self, subject_name): """ Add a subject by subject name Parameters: subject_name (str): name of the subject Returns: subject(Subject): subject that was added """ self._subjects.append(Subject(subject_name)) return self._subjects[-1]
def main(): startTime = datetime.now() runList = genSubjectList('t2_circles') for subject in runList: subject = Subject(subject) subjectDisplay(subject) print 'Subject Creation: ', datetime.now() - startTime
def add_test_data(subjects, students): subjects.append(Subject("German")) students.append(Student("Donald", "Duck")) students[len(students) - 1].add_score(subjects[1], "01.01.2019", Student.ABSENT) students[len(students) - 1].add_score(subjects[2], "01.01.2019", Student.ABSENT) students.append(Student("Test", "Student")) students[len(students) - 1].add_score(subjects[0], "01.06.2030", 90) students[len(students) - 1].add_score(subjects[2], "0w.07.2023", 44) students.append(Student("Klaus", "Muster")) students[len(students) - 1].add_score(subjects[0], "01.04.2019", 77) students[len(students) - 1].add_score(subjects[2], "03.03.2019", Student.ABSENT) students[len(students) - 1].add_score(subjects[2], "10.03.2019", 64) students[len(students) - 1].add_score(subjects[2], "17.03.2019", 20) students.append(Student("Test", "Studentin")) students[len(students) - 1].add_score(subjects[0], "01.06.2030", 90) students[len(students) - 1].add_score(subjects[2], "0w.07.2023", 44) students.append(Student("Muster", "Studentin")) students[len(students) - 1].add_score(subjects[0], "01.06.2030", 90) students[len(students) - 1].add_score(subjects[2], "0w.07.2023", 44) students.append(Student("Muster", "Student")) students[len(students) - 1].add_score(subjects[0], "01.06.2030", 91) students[len(students) - 1].add_score(subjects[2], "0w.07.2023", 33) students.append(Student("Debug", "Studentin")) students[len(students) - 1].add_score(subjects[0], "01.06.2030", 90) students[len(students) - 1].add_score(subjects[0], "0w.07.2023", 44) students.append(Student("Debug", "Studentin")) students[len(students) - 1].add_score(subjects[1], "01.06.2030", 90) students[len(students) - 1].add_score(subjects[2], "0w.07.2023", 44) students.append(Student("Debug", "Student")) students[len(students) - 1].add_score(subjects[0], "01.06.2030", 91) students[len(students) - 1].add_score(subjects[1], "0w.07.2023", 33) students.append(Student("Thomas", "Muster")) students[len(students) - 1].add_score(subjects[0], "01.04.2019", 77) students[len(students) - 1].add_score(subjects[2], "03.03.2019", Student.ABSENT) students[len(students) - 1].add_score(subjects[2], "10.03.2019", 64) students[len(students) - 1].add_score(subjects[2], "17.03.2019", 20) return subjects, students
def make_student_real_subject_list(self): real_subject_list = [] for idx, best_subject_study_time in enumerate( self.best_solo_subject_study_case): if best_subject_study_time > 0: real_subject = copy.deepcopy(self.subject_list[idx]) real_subject.bt = best_subject_study_time real_subject.remain_bt = real_subject.bt real_subject_list.append(real_subject) if self.best_each_team_play_time > 0: real_subject_list.append( Subject("팀프", 3, self.best_each_team_play_time, 14, -1), ) return real_subject_list
def mapping_to_subject(datum): return Subject(datum['subject_id'], datum['name'], datum['region'], datum['section'], datum['kind'], datum['price'], datum['location'], datum['sub_type'], datum['pattern'], datum['size'], datum['floor'], datum['contact_person'], datum['url'])
def getSynthesis(): try: id_str = (request.form['subject'] + str(time())).replace(' ', '-') if request.form.get('wikipedia'): useWikipedia = True else: useWikipedia = False subject = Subject(request.form['subject'], summaryLength=int(request.form['lines']), useWikipedia=useWikipedia) q.enqueue(subject.build, job_id=id_str, timeout=600) except Exception as e: return '<h1>Error</h1>' + str(e) return render_template('working.html', url='/status/' + id_str)
def enter(): global student, subject, room, randombox, warning_bgm, buy_bgm, font student = Student() subject = Subject() room = Room() randombox = [] font = load_font('ENCR10B.TTF', 16) warning_bgm = load_music('sounds/effects/warning.mp3') warning_bgm.set_volume(128) buy_bgm = load_music('sounds/effects/buy.mp3') buy_bgm.set_volume(128)
def task_actions(task_action, task_subject): for subject_name in task_subject: subject = Subject.get(subject_name) q2html = subject.render.q2html subject_db = db[subject_name] if 'suits' in task_action: print subject_name, 'cache suits start' cache_suits(subject_db, q2html, subject_name=subject_name) if 'plans' in task_action: print subject_name, 'cache plans start' cache_plans(subject_db, q2html, subject_name=subject_name) if 'items' in task_action: print subject_name, 'cache all items start' cache_items(subject_db, q2html, subject_name=subject_name)
def __getSubjectsDirectories(self): """Return directories who qualified for the pipeline Look into each subdirectory if it meet all the requirements. If yes, the subdirectory is consider a subject and is register into a list Returns: subjects: a list of directory containing qualified subjects """ self.info("Looking for valid subjects.") subjects = [] if self.arguments.subject: for dir in self.arguments.subject: if self.__isDirAValidSubject(dir): subjects.append(Subject(self.__copyConfig(dir))) else: dirs = glob.glob("{}/*".format(self.studyDir)) for dir in dirs: if self.__isDirAValidSubject(dir): subjects.append(Subject(self.__copyConfig(dir))) return subjects
def set_species(self, dat): ''' Set the species list ''' if dat != None: self.species = [] dat.sort(key=itemgetter(self.key)) temp_set = set() # to avoid duplicates from observations for e in dat: temp_name = e[1] + e[2] subject = Subject(e[0], e[1], e[2], e[3], e[4], e[5], e[6]) if not (temp_name in temp_set): temp_set.add(temp_name) self.species.append(subject)
def find(self, subject_name): """ Find a subject by subject name Parameters: subject_name (str): name of the subject Returns: subjects(list): list of subjects """ try: sub_index = self._subjects.index(Subject(subject_name)) return self._subjects[sub_index] except ValueError: return None
def __subjectsFactory(self, directories): """Return a list of directories who qualified for the pipeline Args: directories: a list of directory to validate Returns: subjects: a list of directory containing qualified subjects """ subjects=[] for directory in directories: subject = Subject(self.__copyConfig(directory)) if subject.isAToadSubject(): subject.activateLogDir() self.info("{} seem\'s a valid toad subject entry".format(directory)) if self.config.getboolean('arguments', 'validation'): if subject.isValidForPipeline(): self.info("{} is a valid subject, adding it to the list.".format(subject)) subjects.append(subject) elif self.config.getboolean('arguments', 'prompt'): msg = "It seem\'m like {} is having an issue and will probably fail!".format(subject) if util.displayYesNoMessage(msg, "Would you like to remove it from the list (y or n)"): self.info("Removing subject {} from the submitting list\n".format(subject)) else: self.warning("Keeping {} even if we found issues will probably make the pipeline failing\n" .format(subject)) subjects.append(subject) else: self.warning("Command prompt disabled, this submit will be submit anyway") subjects.append(subject) else: self.warning("Skipping validation have been requested, this is a unwise and dangerous decision") subjects.append(subject) return subjects
def __init__(self, url=None, version=None, token=None): self.subject = Subject() self.aspect = Aspect() self.sample = Sample() if url: if url.endswith('/'): config.REFOCUS_URL = url else: config.REFOCUS_URL = url + '/' if config.API_VERSION or version: config.REFOCUS_URL += version if version else config.API_VERSION if token: config.REFOCUS_TOKEN = token
def decode(data): subjects = [] students = [] for s in data["subjects"]: subjects.append(Subject(s["name"])) for s in data["students"]: student_append = Student(s["firstname"], s["lastname"]) scores = s["scores"] score_keys = scores.keys() for subject_name in score_keys: subject_obj = None for o in subjects: if o.name == subject_name: subject_obj = o student_append.scores[subject_obj] = scores[subject_name] students.append(student_append) return (subjects, students)
def load(self): data_path = os.path.join(self.path, 'DATA') increment = 0 files = os.listdir(data_path) for i, f in enumerate(files): if i == self.size: print("aqui") break print(" Percentage : {:.2f}".format((increment / len(files)) * 100) if self.size is None else (increment / self.size)) if f.endswith(".xml") and f.startswith("subject"): sub = Subject(ET.parse(os.path.join(data_path, f)).getroot()) self.subjects.append(sub) increment += 1 self._load_gt()
def main(): startTime = datetime.now() outTable = r'C:\Users\jeffr_000\Desktop\Fall_2016\415\GEOG_415_Scarmazzi\Results\FinalRun_C.csv' writer = csvGen(outTable) ## # T1 = 134 Subjects, T2 = 133 Subjects ## subjectList = genSubjectList('t2_circles') errList = [] runList = [] for subject in subjectList: subjectNumber = subject subject = Subject(subject) try: t1Generation(subject, 't1_circles') t2Generation(subject, 't2_circles') except Exception as e: errList.append(subjectNumber) print '#' * 75 print 'Problem: ', e.args print '#' * 75 subjectDisplay(subject) csvWrite(writer, subject) runList.append(subject) print 'Subject Creation: ', datetime.now() - startTime print 'Problem Subjects: ', len(errList), errList print '*' * 50 print '*' * 50 ## # Console Logging ## r1Logging(runList) configLogging(runList)
def __init__(self, superuser=None, computer=None, user=None, code=None, branch=None, id_local_process='unused', type_list=[None], case_list=[[None]], configuration_list=[None], flow_process_list=[None], element_type_list=[[None]], operation_type=None, operation=None, test_mode='0', db_user='******', db_password='******', db_host='localhost', db_schema='testing_environment'): """ These parameters can be preselected: belong to (test) Subject: :param superuser: has accounts on separate computer :param computer: :param user: :param code: belongs to source code tree :param branch: belongs to source code tree belong to (test) Item: :param type_list: belongs to example tree :param case_list: belongs to example tree :param configuration_list: belongs to example tree :param flow_process_list: :param element_type_list: :param operation_type: one-character string [b: building,s: simulating,p: plotting] :param operation: one-character string - meaning depends on operation_type :param test_mode: Parameters to access database: :param db_user: :param db_password: :param db_host: :param db_schema: """ self.__flow_process_name_list = flow_process_list self.__element_type_name_list = element_type_list db_inst = Database(db_user, db_password, db_host, db_schema) self.__subject_inst = Subject(superuser, computer, user, code, branch, id_local_process) self.__setting_inst = Setting(type_list, case_list, configuration_list, operation_type, operation, test_mode, db_inst) if location == 'local': self.__subject_inst.print_selected_variables() self.__setting_inst.print_selected_variables() print('\n-----------------------------------------------------------------')
def main(argv=None): if argv is None: argv = sys.argv[1:] parser = optparse.OptionParser() # add options here # ... opts, args = parser.parse_args(argv) # dummy run-through import lxml.etree as ET from subject import Subject logging.basicConfig() # log.setLevel(logging.DEBUG) # noisy error callback def raise_err(err): raise err.err subject = Subject.forpath('source/Case2.txt') errors = [] messages = ET.parse(args[0]).getroot() messages_savedcopy = deepcopy_element(messages) # TODO: following is out of date # pipeline = SelectionPipeline(subject, errors) # processed_messages = pipeline(messages) if errors: print "Errors:" pprint(errors) return 1 print ET.tostring(processed_messages) # TEMP sanity check from tailoring.elementutil import normalize def compare(a, b): # normalize and compare serializations normalize(a) normalize(b) return ET.tostring(a) == ET.tostring(b) assert compare(messages, messages_savedcopy) assert not compare(messages, processed_messages)
def __init__(self, experiments_json, subjects_json, model_dir, subject_analyses, group_analyses, image_dir, jsons_dir="./jsons", model_type="english1000"): self.model_type = model_type all_exp_info = read_json(experiments_json, jsons_dir) # exp2 = dict() # exp2['Binder2005'] = all_exp_info['Binder2005'] # all_exp_info = exp2 #all_exp_info2 = dict() #all_exp_info2['Bedny2013'] = all_exp_info['Bedny2013'] #all_exp_info = all_exp_info2 model_holder = ModelHolder(jsons_dir) self.experiments = { key: Experiment(model_holder=model_holder, name=key, image_dir=image_dir, model_type=self.model_type, nperm=1000, **info) for (key, info) in all_exp_info.items() } subjects_info = read_json(subjects_json, jsons_dir) subjects = [ Subject(name=key, model_type=self.model_type, model_dir=model_dir['subject_dir'], analyses=subject_analyses, **info) for (key, info) in subjects_info.items() ] self.subject_group = SubjectGroup(subjects, group_analyses)
def setup(script_name=''): Subject.Subject_name settings.define_app_options() self_dir = os.path.dirname(os.path.abspath(__file__)) parse_command_line(final=False) conf_filename = "server.conf" if not options.debug: conf_filename = "prod.conf" conf_filename = os.path.join(os.path.dirname(self_dir), conf_filename) if os.path.exists(conf_filename): parse_config_file(conf_filename, final=False) else: print 'no {} found. skip it'.format(conf_filename) parse_command_line(final=True) setup_log(options) dbs = {} for subject in Subject.Subject_name: dbs[subject] = MongoClient(options.mongodb_host, replicaSet=options.replica_set)[options[subject+'db_name']] print 'Connected to '+subject+'db ', options.mongodb_host env = Env env.db = dbs env.tc = {} env.deeprender_host = options.deeprender_host env.subject = Subject.get('math') if not options.debug: channel = logging.StreamHandler(sys.stdout) channel.setFormatter(LogFormatter()) logging.getLogger().addHandler(channel) gen_log.info("Env was setup for %s. Subject: %s", script_name, env.subject.zh_name) return env
def notify(self, unix_timestamp): time = datetime.datetime.fromtimestamp(int(unix_timestamp)).strftime('%Y-%m-%d %I:%M:%S%p') print 'Observer', self.name, 'says:', time class EUTimeObserver(Observer): def __init__(self, name): self.name = name def notify(self, unix_timestamp): time = datetime.datetime.fromtimestamp(int(unix_timestamp)).strftime('%Y-%m-%d %H:%M:%S') print 'Observer', self.name, 'says:', time if __name__ == '__main__': subject = Subject() print 'Adding usa_time_observer' observer1 = USATimeObserver('usa_time_observer') subject.register_observer(observer1) subject.notify_observers() time.sleep(2) print 'Adding eu_time_observer' observer2 = EUTimeObserver('eu_time_observer') subject.register_observer(observer2) subject.notify_observers() time.sleep(2) print 'Removing usa_time_observer' subject.unregister_observer(observer1)
def load(s): return Subject.load(s)
class Environment: """ main object of icbc: hosts instance of classes subject, setting """ def __init__(self, superuser=None, computer=None, user=None, code=None, branch=None, id_local_process='unused', type_list=[None], case_list=[[None]], configuration_list=[None], flow_process_list=[None], element_type_list=[[None]], operation_type=None, operation=None, test_mode='0', db_user='******', db_password='******', db_host='localhost', db_schema='testing_environment'): """ These parameters can be preselected: belong to (test) Subject: :param superuser: has accounts on separate computer :param computer: :param user: :param code: belongs to source code tree :param branch: belongs to source code tree belong to (test) Item: :param type_list: belongs to example tree :param case_list: belongs to example tree :param configuration_list: belongs to example tree :param flow_process_list: :param element_type_list: :param operation_type: one-character string [b: building,s: simulating,p: plotting] :param operation: one-character string - meaning depends on operation_type :param test_mode: Parameters to access database: :param db_user: :param db_password: :param db_host: :param db_schema: """ self.__flow_process_name_list = flow_process_list self.__element_type_name_list = element_type_list db_inst = Database(db_user, db_password, db_host, db_schema) self.__subject_inst = Subject(superuser, computer, user, code, branch, id_local_process) self.__setting_inst = Setting(type_list, case_list, configuration_list, operation_type, operation, test_mode, db_inst) if location == 'local': self.__subject_inst.print_selected_variables() self.__setting_inst.print_selected_variables() print('\n-----------------------------------------------------------------') def __del__(self): del self.__subject_inst del self.__setting_inst def run(self): """ main function of icbc: 1. connect to and disconnect from data base if on local computer 2. call select functions 3. call loop if selects successful :return: 0 """ if location == 'local': self.__setting_inst.connect_to_db() operation_inst = self.select() # rerun if reselect chosen if operation_inst == 1: self.run() # rerun self.loop(operation_inst) del operation_inst if location == 'local': self.__setting_inst.disconnect_from_db() # to reconnect each run in case of table update if self.__setting_inst.test_mode == '0': # control with shell self.run() return 0 def select(self): """ select 1. select operation type and operation 2. do configurations which are independent of test item 3. select test items :return: (Operation(Building, Simulating, or Plotting)) operation instance; 1 if operation reselect or exception """ self.__subject_inst.select(self.__setting_inst) selected_operation_type = self.__setting_inst.select_operation_type() operation_inst = self.select_operation(selected_operation_type) if operation_inst == 1: return 1 if operation_inst.selected_operation == 's': # reselect self.__setting_inst.reselect(self.__subject_inst) # decide what to reselect return 1 self.configure(operation_inst) self.__setting_inst.select_items_to_test(selected_operation_type, operation_inst.selected_operation, self.__subject_inst.computer) if self.__setting_inst.operation == 'reselect': self.__setting_inst.operation = None self.run() # now reselection is finished, rerun to select next operation return operation_inst def select_operation(self, operation_type): """ 1. generate operation instance, 2. call select_operation where operation is chosen :param operation_type: one-character string [b: building,s: simulating,p: plotting] :return: operation instance Building, Simulating, Plotting; 1 if error """ if operation_type == 'b': # building operation_inst = Building(self.__subject_inst) elif operation_type == 's': # simulating operation_inst = Simulating(self.__subject_inst) elif operation_type == 'p': # plotting operation_inst = Plotting(self.__subject_inst) else: message(mode='ERROR', not_supported=operation_type) return 1 operation_inst.select_operation(self.__setting_inst.operation) return operation_inst def configure(self, operation_inst): """ 0. call function to set flags for file uploads 1. if operation is to compare results with references, clear log file with names of deviating files from previous runs 2. check if list entries for test items exit :param operation_inst: (class Building, Simulating, Plotting (Operation)) :return: 0 if success; 1 if lists for item not complete """ operation_inst.set_upload_file_flags() if operation_inst.selected_operation_type == 's' and operation_inst.selected_operation == 'o': # the selected operation is to compare results with references files = glob(adapt_path('{}references\\deviatingFiles*'.format(self.__subject_inst.directory))) for file in files: remove_file(file, False) #clear_file(adapt_path('{}references\\deviatingFiles_{}.log'.format( # self._subject_inst.directory, self._item.configuration))) def loop(self, operation_inst): """ loop over type, case, and configuration lists :param operation_inst: (class Building, Simulating, Plotting (Operation)) :return: """ type_list_counter = 0 for item_type in self.__setting_inst.item_constituents.type_list: for item_case in self.__setting_inst.item_constituents.case_list[type_list_counter]: self.set_inner_loop_elements(item_case) for item_configuration in self.__setting_inst.item_constituents.configuration_list: if self.item_is_to_test(item_case): self.loop_inner(operation_inst, item_type, item_case, item_configuration) if len(self.__setting_inst.item_constituents.case_list) > 1: type_list_counter += 1 def set_inner_loop_elements(self, item_case): """ set lists with process name and element type :param item_case: (string) :return: """ if item_case is None: self.__flow_process_name_list = [None] self.__element_type_name_list = [[None]] else: if location == 'local': self.__flow_process_name_list = self.__setting_inst.query_flow_process_name_list(item_case) self.__element_type_name_list = self.__setting_inst.query_element_type_name_list( item_case, self.__flow_process_name_list) def item_is_to_test(self, item_case): """ check test_mode, state, used for simulation, plotting operation type (case item exists) (all items (i.e. configurations) involved in building operation type) :param item_case: (string or None) :return: (bool )False: not involved, True: involved or ERROR """ execute_flag = True if location == 'local' and item_case: if self.__setting_inst.test_mode == '0': # no test mode - select everything by typing on console # and than the items in the loop (in environment run) is involved pass elif self.__setting_inst.test_mode == '1': # via browser execute_flag = self.__setting_inst.query_column_entry_for_name('cases', item_case, 'state') elif self.__setting_inst.test_mode == '2': # via CI tool if not self.__setting_inst.query_column_entry_for_name('cases', item_case, 'active'): execute_flag = False else: message(mode='ERROR', not_supported=self.__setting_inst.test_mode) # returns '1' return execute_flag # remote always '1' def loop_inner(self, operation_inst, item_type, item_case, item_configuration): """ 1. generate (and delete) item instance 2. call write files (for numerics, processing) 3. call operation run function :param operation_inst: (class Building, Simulating, or Plotting) :param item_type: (string) :param item_case: (string) :param item_configuration: (string) :return: """ for index, flow_process_name in enumerate(self.__flow_process_name_list): for element_type_name in self.__element_type_name_list[index]: # take all for remote, building or plotting if location == 'remote' or operation_inst.selected_operation_type == 'b' or \ operation_inst.selected_operation_type == 'p' or\ (str2bool(self.__setting_inst.query_column_entry_for_name( 'flow_processes', flow_process_name, 'active')) and str2bool(self.__setting_inst.query_column_entry_for_name( 'element_types', element_type_name, 'active'))): item_inst = self.generate_item_instance( operation_inst, item_type, item_case, item_configuration, flow_process_name, element_type_name) operation_inst.set_numerics_and_processing_data(item_type, item_case, item_configuration, flow_process_name, element_type_name, self.__setting_inst, self.__subject_inst.location) operation_inst.run(item_inst) del item_inst def generate_item_instance( self, operation_inst, item_type, item_case, item_configuration, flow_process, element_type): """ generate Build, Sim or Plot according to chosen operation :param operation_inst: :param item_type: :param item_case: :param item_configuration: :param flow_process: :param element_type :return: child of Item instance (Build, Sim, Plot) """ if operation_inst.selected_operation_type == 'b': # building return Build(self.__subject_inst, item_configuration) elif operation_inst.selected_operation_type == 's': # simulating return Sim(self.__subject_inst, item_type, item_case, item_configuration, flow_process, element_type) elif operation_inst.selected_operation_type == 'p': # plotting return Plot(self.__subject_inst, item_type, item_case, item_configuration, flow_process, element_type) else: message(mode='ERROR', not_supported=operation_inst.selected_operation_type) return 1 # check this
def __init__(self, number_of_correct_answer=0): Subject.__init__(self, 'KOREA', 4, number_of_correct_answer)
def __init__(self, ip, port, username, password): Subject.__init__(self) print('Connecting...') self.network_connect(ip, port, username, password)
def load_student_data(filename): """A function that reads data from a CSV file and stores it into objects. Args: filename: Name of the file Returns: A dictionary of Grade objects. """ grades_dict = {} csv_f = open(filename, 'r') i = 0 for line in csv_f: # print "line no:", i, "=", line if i > 0: # We don't need to read the header, so # we do not read line 0 line_list = [] line_list = line.split(',') grade_number = int(line_list[0]) # Only create a grade object if it doesn't already exist if grade_number in grades_dict: grade_temp = grades_dict[grade_number] else: grade_temp = Grade(grade_number) sections_dict = grade_temp.get_sections() section_number = int(line_list[1]) # Only create a section object if it doesn't already exist # in that grade if section_number in sections_dict: section_temp = sections_dict[section_number] else: section_temp = Section(section_number) students_dict = section_temp.get_students() student_name = line_list[2] # Only create a student object if it doesn't already exist # in that section if student_name in students_dict: student_temp = students_dict[student_name] else: student_temp = Student(student_name) subjects_dict = student_temp.get_subjects() subject_name = line_list[3] # Only create a subjects object if it doesn't already exist # in that student object if subject_name in subjects_dict: subject_temp = subjects_dict[subject_name] else: subject_temp = Subject(subject_name) tests_dict = subject_temp.get_tests() test_obj = Test(line_list[4], int(line_list[5]), int(line_list[6]), line_list[7], line_list[8]) tests_dict[test_obj.get_test_name()] = test_obj subject_temp.set_tests(tests_dict) subjects_dict[subject_temp.get_subject_name()] = subject_temp student_temp.set_subjects(subjects_dict) students_dict[student_temp.get_student_name()] = student_temp section_temp.set_students(students_dict) sections_dict[section_temp.get_section_number()] = section_temp grade_temp.set_sections(sections_dict) grades_dict[grade_temp.get_grade_number()] = grade_temp # variable i tracks line numbers read i = i + 1 csv_f.close() return grades_dict
def __init__(self, name=""): Subject.__init__(self) self.name = name self.data = None
def __init__(self, number_of_correct_answer=0): Subject.__init__(self, 'ENGLISH', 5, number_of_correct_answer)
def __init__(self, number_of_correct_answer=0): Subject.__init__(self, 'MATH', 3, number_of_correct_answer)