def execute(self, driver, config): try: if self.config_key == None: self.param = "" else: if self.config_key in config.params: self.param = config.params[self.config_key] else: raise Exception( "Cannot execute command %s as there was no key named %s in the config params" % (self.command, self.config_key)) self.driver = driver result = Result(passed=True, message="Execute %s %s" % (self.__repr__(), self.param)) logging.debug("Execute : %s %s" % (self.__repr__(), self.param)) if self.command == self.NAVIGATE: self.driver.get(self.param) elif self.command == self.CLICK: WebElement(self.driver, self.element.locators).click() elif self.command == self.SENDKEYS: WebElement(self.driver, self.element.locators).send_keys(self.param) elif self.command == self.VERIFY: WebElement(self.driver, self.element.locators).highlight() else: raise ValueError("Command not supported: %s" % self.command) except Exception as e: logging.debug("Exception : %s" % str(e)) result = Result(passed=False, message="Command raised an exception %s" % str(e), exception=str(e)) finally: self.execution_results.append(result) return result
def delete_by_uuid(cls, del_uuid): execution = Execution.query.filter_by(uuid=del_uuid) if execution: from models.result import Result linked_results = Result.query.filter_by(execution_uuid=del_uuid) for result in linked_results: Result.delete_by_uuid(result.uuid) execution.delete() # rmtree(self.fq_storage_path) db_session.commit()
def insert_profiles(base_url, db_path, driver_list, category): current_file = os.path.basename(__file__) current_file_name = os.path.splitext(current_file)[0] for driver_id in driver_list: url = base_url + "/" + current_file_name + "/" + str( driver_id) + "/" + category try: print(url) response = requests.get(url) except requests.exceptions.RequestException as e: print(e) sys.exit(1) if response.status_code == 200: doc = pq(response.text) connection = sqlite3.connect(db_path) try: if doc("main > div").eq(0).hasClass("profile"): # Header - Driver Info driver = Driver(doc, driver_id) connection.execute( '''INSERT INTO drivers (id,fullname,name,lastname,birthdate,deathdate,nationality,created_at,updated_at,deleted_at) VALUES (?,?,?,?,?,?,?,?,?,?)''', driver.get_tuple()) # Starts-WRC for season in doc.items("h5.profile-season"): starts = season.nextAll('div.profile-starts').eq(0) for start in starts('div.profile-start-line').items(): result = Result(driver.id, season, start) connection.execute( '''INSERT INTO results (event_id,driver_id,codriver_id,season,car_number,car,plate,team,chassis,category,result,created_at,updated_at,deleted_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)''', result.get_tuple()) connection.commit() except Exception as e: connection.rollback() raise e finally: connection.close()
def result_counter(result): final = Result() for item in result: for key, value in item.items(): if key == 'viewCount': final.view_count += int(value) elif key == 'subscriberCount': final.subscribers = int(value) elif key == 'commentCount': final.comments += int(value) elif key == 'dislikeCount': final.dislikes_count += int(value) elif key == 'likeCount': final.likes_count += int(value) return final
def result_download(result_id, label): if result_id is not None: results = [get_result(result_id)] else: results = get_all_results(label=label) if results is None or len(results) == 0: return json.dumps({ 'status': 'error', 'code': 1 }), 404, { 'ContentType': 'application/json' } out_path = f'public/results_{time.time()}.zip' zipf = zipfile.ZipFile(out_path, 'w', zipfile.ZIP_DEFLATED) for r in results: zipf.writestr(f'result_{r.id}.json', r.toJson()) if len(results) > 1: zipf.writestr('results.json', Result.toListJson(results)) zipf.close() file = io.FileIO(out_path, 'r') memory_file = io.BytesIO() memory_file.write(file.readall()) memory_file.seek(0) file.close() os.remove(out_path) return send_file(memory_file, attachment_filename='results.zip', as_attachment=True)
def run(self): # Check preprocessor if self.preprocessor == None: self.__log(Log('No preprocessor', Severity.ERROR)) return Result(self.minSupport, self.maxGap, errors=['No preprocessor']) self.__log( Log('Starting algorithm: {}'.format(self.algorithm.__name__), Severity.INFO)) t0 = perf_counter() mdb, skippedDays = self.preprocessor.GenerateTemporalMdb() preTime = perf_counter() - t0 t0 = perf_counter() results = self.algorithm(mdb, self.logger, self.minSupport, self.maxGap) results.algorithmTime = perf_counter() - t0 results.skippedDays = skippedDays results.dataset = self.dataset results.preprocessingTime = preTime results.job = self self.results = results return self.results
def delete_local_results(run_id=None, result_id=None, strat_id=None, label=None): files_to_remove = [] if strat_id is not None: files_to_remove = list( set(glob.glob(f'public/strat_{strat_id}/result_*.json'))) for f in files_to_remove[:]: with open(f, 'r') as file: txt = file.read() if not is_json(txt): files_to_remove.remove(f) elif run_id is not None or result_id is not None or label is not None: files_to_remove = list(set(glob.glob(f'public/**/result_*.json'))) for f in files_to_remove[:]: with open(f, 'r') as file: txt = file.read() if not is_json(txt): files_to_remove.remove(f) continue result = Result.fromJson(txt) if (run_id is not None and result.config[0]['run_id'] != run_id ) or (result_id is not None and result.id != result_id ) or (label is not None and result.config[0]['label'] != label): files_to_remove.remove(f) for f in files_to_remove: os.remove(f) return files_to_remove
def create_result(self, test_id, execution_uuid): if not execution_uuid: self.__outputs[test_id] += f'\nNo Execution UUID provided.' result = Result.create(execution_uuid) if result.uuid: self.__outputs[test_id] += f'\nCreated result: {result}' return result.uuid return None
def tpminer(mdb, logger, minSupport, maxGap): patternSets = tpminer_main(mdb, minSupport, logger) # Convert set to list patterns = [] for p in patternSets: patterns.append(p) return Result(minSupport, maxGap, patterns, [])
def get_results(): # noqa: E501 """Get all results # noqa: E501 :rtype: List[Result] """ results = ResultImpl.get_all() return result_schema_many.dump(results)
def get_repositories(): search_term = request.args.get('search_term') if not search_term: return render_template('repos.html', result=Result(search_term, [])) github_service = GithubService( 'https://api.github.com/search/repositories') loop = asyncio.get_event_loop() task = loop.create_task(github_service.get_repositories(search_term)) repositories = loop.run_until_complete(task) if not loop.is_running: loop.stop() end = time.time() return render_template('repos.html', result=Result(search_term, repositories))
def get_result_by_uuid(result_uuid): # noqa: E501 """Retrieve a result # noqa: E501 :param result_uuid: UUID of the result to return :type result_uuid: str :rtype: Result """ result = ResultImpl.get_by_uuid(result_uuid) return result_schema.dump(result)
def delete_result_by_uuid(result_uuid): # noqa: E501 """Delete a result Deletes the result with the given UUID on it # noqa: E501 :param result_uuid: UUID of the result to delete :type result_uuid: str :rtype: Result """ result = ResultImpl.delete_by_uuid(result_uuid) return result_schema.dump(result)
def run_package(): suite = PackageSuite.query.all() total = 0 passes = 0 fail = 0 pid = request.args.get("pid") result = Result(pid, passes + fail, passes, fail, datetime.date.today().isoformat(), "Scheduled", 0, "") db.session.add(result) db.session.commit() return redirect("/results/")
def run_problems(input_filename, h_list, heur, processes): results = [] with mp.Pool(processes=processes) as pool: if heur == 'cons': data_file_path = BASE_DIR + '/data/{}.txt'.format(input_filename) for problem in read_problems(data_file_path): n_jobs = problem['n_jobs'] df = problem['df'] total_p = df['p'].sum() result = [] for h in h_list: d = int(h * total_p) t = time.process_time() schedule = heur_cons.create_schedule(df, d, h) elapsed_t = time.process_time() - t # veryfing if sequence is valid utils_test.sequence_test(n_jobs, schedule) cost = utils.get_cost(schedule) result_h = Result(n_jobs, h, schedule, cost, elapsed_t) result.append(result_h) results.append(result) elif heur in ['local', 'tabu']: data_file_path = BASE_DIR + \ '/output/{}-cons-results.txt'.format(input_filename) h_list_len = len(h_list) result = [] result_h = pool.starmap( multiprocessing_func, zip(read_cons_results(data_file_path), repeat(heur))) for e in result_h: result.append(e) if len(result) >= h_list_len: results.append(result) result = [] else: raise ValueError('Selected Heuristic do not exist') return results
def armada(mdb, logger, minSupport, maxGap): supportList = Support.GenerateStateSupportList(mdb) mdb = Support.RemoveNonSupported(minSupport, supportList, mdb) logger.log(Log('Non-Supported states removed', Severity.INFO)) frequentStates = Support.ExtractFrequentStates(minSupport, supportList, mdb) logger.log( Log('Frequent states found: ' + str(len(frequentStates)), Severity.INFO)) patterns = Armada(mdb, frequentStates, minSupport, maxGap, logger) return Result(minSupport, maxGap, patterns, frequentStates)
def get_marks(self,sector,type_of_result,predictions,stock_data): if sector != 'technology': stock_movement,difference = self.stock_calculator.stock_movement(stock_data.tail(1)) else: stock_movement,difference = self.stock_calculator.stock_movement(stock_data,'technology') keys = list(predictions.keys()) results = [] for key in keys: if key != 'HAS_CHANGED': check_if_correct = self.check_if_correct(predictions[key],stock_movement) now = datetime.datetime.now() new_result = Result(sector=sector,type=type_of_result,machine_learning_technique=key,date=now.strftime("%Y-%m-%d %H:%M"),prediction=predictions[key],result=check_if_correct,difference=difference,has_changed=predictions['HAS_CHANGED']) results.append(new_result) return results
def cmp_data(youtube_data): cmped_result = Result() db_data = get_data_from_file() cmped_result.likes_count = youtube_data.likes_count - db_data.likes_count cmped_result.dislikes_count = youtube_data.dislikes_count - db_data.dislikes_count cmped_result.comments = youtube_data.comments - db_data.comments cmped_result.subscribers = youtube_data.subscribers - db_data.subscribers cmped_result.view_count = youtube_data.view_count - db_data.view_count return cmped_result
def execute(self, driver): logging.debug("Executing Suite %s" % self.name) self.driver = driver suite_result = Result(passed=True,message="Passed",exception="Passed") for test in self.tests: test_result = test.execute(driver) suite_result.step_results.append(test_result) if not test_result.passed: suite_result.passed = False suite_result.message = str(self.__class__) suite_result.exception = test_result.exception suite_result.failed_state = test_result.failed_state suite_result.actual_state = test_result.actual_state suite_result.html = self.driver.page_source suite_result.screenshot = self.driver.get_screenshot_as_base64() self.suite_results.append(suite_result) self.cascade_save() return suite_result
def download_result_by_uuid(result_uuid): # noqa: E501 """Downloads the generated results # noqa: E501 :param result_uuid: UUID of the result to download :type result_uuid: str :rtype: file """ result = ResultImpl.get_by_uuid(result_uuid) if os.path.isfile(result.fq_result_storage_path): return send_file(result.fq_result_storage_path, as_attachment=True, attachment_filename="Results.zip") else: return None
def create_result(post_result=None): # noqa: E501 """Creates a new result # noqa: E501 :param post_result: :type post_result: dict | bytes :rtype: None """ if connexion.request.is_json: post_result = POSTResult.from_dict(connexion.request.get_json()) # noqa: E501 created_result = ResultImpl.create(post_result.execution_uuid) return result_schema.dump(created_result)
def read_cons_results(data_file_path): with open(data_file_path, 'r') as sch_file: n_problems = int(sch_file.readline().strip()) h_list = [float(e) for e in sch_file.readline().strip().split(';')] n_jobs = int(sch_file.readline().strip()) for _ in range(n_problems): job = int(sch_file.readline().strip()) for _ in h_list: h, d, start, early_seq, tardy_dict, cost = sch_file.readline( ).strip().split('|') schedule = Schedule(int(d), int(start), OrderedDict(json.loads(early_seq)), OrderedDict(json.loads(tardy_dict))) result = Result(n_jobs, float(h), schedule, int(cost)) yield result
def results(result_id, label): if result_id is not None: result = get_result(result_id) if result is None: result = json.dumps(result) else: result = result.toJson() else: result_list = get_all_results(label=label) if label is None: result_list = list(set([x.config[0]['label'] for x in result_list])) result = Result.toListJson(result_list) return result, 200, {'ContentType': 'application/json'}
def get_results(self): cycle = self.cycle settings = self.settings results = Result( time_avg_cost=round(cycle.time_avg_rebalance_cost, 3), time_avg_cond_drift=round(cycle.time_avg_cond_drift, 3), obj_function=round( cycle.time_avg_rebalance_cost * settings.cost_coef + cycle.time_avg_cond_drift, 3), moved_bike_total_count=cycle.cumulative_moved_bike_count, rebalanced_bike_total_count=cycle.cumulative_rebalanced_bike_count, total_cycles=cycle.count + 1, simulation_hour=(cycle.count + 1) * settings.interval_hour, distance_moved=cycle.distance_moved, demand_supply_gap_total_decrement=cycle. cumulative_demand_supply_gap_decrement) self.simulation.set_result(results) return results
def get_all_results(self): self._db_cur.execute('SELECT * FROM result', ()) results = [] row = self._db_cur.fetchone() while row: result = Result() result.request_id = row[1] result.adress = row[3] result.square = row[6] result.region_id = row[8] results.append(result) row = self._db_cur.fetchone() return results
def multiprocessing_func(cons_result, heur): t = time.process_time() if heur == 'local': search_func = heur_local.create_schedule elif heur == 'tabu': search_func = heur_tabu.create_schedule cost, schedule = search_func(cons_result.n_jobs, cons_result.schedule, cons_result.cost) utils_test.sequence_test(cons_result.n_jobs, schedule) elapsed_t = time.process_time() - t cost = utils.get_cost(schedule) result_h = Result(cons_result.n_jobs, cons_result.h, schedule, cost, elapsed_t) return result_h
def __generate(randomizer: Randomizer, settings: Settings, race: bool = False, retries: int = 0) -> Result: if retries >= 3: return None patch = None permalink = None spoiler = None try: patch_start_time = time.perf_counter() logging.info(f"({settings.seed}) Generating patch ({retries + 1} / 3)...") logging.info(f"({settings.seed}) Settings: {str(request.get_json())}") patch = __generatePatch(randomizer, settings) if patch is None: logging.info(f"({settings.seed}) Failed to generate patch in {time.perf_counter() - patch_start_time} seconds!") return __generate(randomizer, settings, race, retries + 1) else: logging.info(f"({settings.seed}) Generated patch in {time.perf_counter() - patch_start_time} seconds!") if not race: logging.info(f"({settings.seed}) Race Mode off, generating spoiler...") spoiler_start_time = time.perf_counter() spoiler = __generateSpoiler(randomizer, settings) logging.info(f"({settings.seed}) Generated spoiler in {time.perf_counter() - spoiler_start_time} seconds!") else: logging.info(f"({settings.seed}) Race Mode on, not generating spoiler...") if database.enabled: logging.info(f"({settings.seed}) Generating permalink...") permalink_start_time = time.perf_counter() permalink = database.create(patch, spoiler, settings) logging.info( f"({settings.seed}) Permalink generated in {time.perf_counter() - permalink_start_time} seconds!") return Result(patch, spoiler, permalink) except Exception as e: logging.exception(e) return __generate(settings, race, retries + 1)
def test_push_results(self): # Make Result model now = datetime.datetime.now() new_result = Result(sector='test', type='test', machine_learning_technique='test', date=now.strftime("%Y-%m-%d %H:%M"), prediction=1, result='0', difference=12.34, has_changed=1) # Push result to database results = [new_result] results_to_db = ResultsToDB() results_to_db.push_results(results) # Create engine engine = create_new_engine('stockbot') Session = create_new_session(engine) session = Session() query = session.query(Result).filter(Result.sector.in_(['test'])).all() self.assertEqual(type(query[0]), Result)
def read_local_results(run_id=None, result_id=None, strat_id=None, label=None): if strat_id is not None: files = list(set(glob.glob(f'public/strat_{strat_id}/result_*.json'))) else: files = list(set(glob.glob(f'public/**/result_*.json'))) results = [] for f in files: with open(f, 'r') as file: txt = file.read() json_r = json.loads(txt) if is_json(txt): results.append(json_r) results_flatten = [] for r in results: if isinstance(r, list): results_flatten = results_flatten + r else: results_flatten.append(r) if run_id is not None: results_flatten = [ r for r in results_flatten if r['config'][0]['run_id'] == run_id ] if result_id is not None: results_flatten = [r for r in results_flatten if r['id'] == result_id] if label is not None: results_flatten = [ r for r in results_flatten if r['config'][0]['label'] == label ] results_list = Result.fromListDict(results_flatten) return results_list
def search_flat(search_form, request_id): payload = utils.create_form_data(search_form.__dict__) res = requests.post('https://extra.egrp365.ru/api/extra/index.php', data=payload.encode('utf-8'), headers=utils.HEADERS) try: json_data = json.loads(res.text) if json_data['success']: db = DB() for x in json_data['data']: result = Result() result.cadastral = x['cn'] result.adress = x['address'] result.floor = x['floor'] # result.response_json = str(json_data) result.region_id = search_form.macroRegionId result.square = square_search(result.cadastral) db.insert(result, 'result') else: SEARCH_SHEDULE.append_request(request_id) except Exception as e: logging.error('Search error. Response text: ' + res.text) raise e
def main(): # Парсим агрументы командной строки, переданные при запуске скрипта из консоли parser = argparse.ArgumentParser() parser.add_argument('--driver', default='{SQL Server}', type=str) parser.add_argument('--server', default='DESKTOP-7APAP23\SQLEXPRESS', type=str) parser.add_argument('--db', default='Poems', type=str) parser.add_argument('--uid', default='Tester', type=str) parser.add_argument('--pwd', default='Tester123', type=str) args = parser.parse_args() # Создаем объект коннектора к серверу и создаем базу, если ее еще не было connector = Connector(args) connector.create_database() # Создаем таблицы в бд Author().create(connector) Poem().create(connector) FirstQuatrain().create(connector) SecondQuatrain().create(connector) Result().create(connector) # Определяем путь к источнику данных (стихов) current_directory = os.getcwd() data_directory = os.path.join(current_directory, 'data') data_list = os.listdir(data_directory) # Обьявляем список для хранения авторов authors_list = [] # Создаем сессии для каждой таблицы session = sessionmaker() session.configure(bind=connector.get_engine()) authors_session = session() poem_session = session() firstQuantrain_session = session() secondQuantrain_session = session() second_parts_list_object = [] # Заполняем таблицы for data in data_list: file_path = os.path.join(data_directory, data) with open(file_path, encoding="utf-8") as file: file_data = file.readlines() poem_title = file_data[0].strip() author_fullname = file_data[1].strip().split(' ') author_firstname = author_fullname[0] auth_secondname = author_fullname[1] authors_list.append(auth_secondname) first_quatrain = ' '.join(x.strip() for x in file_data[2:6]) second_quatrain = file_data[6:] author = Author(first_name=author_firstname, second_name=auth_secondname, objectid=str(uuid4())) authors_session.add(author) authors_session.commit() poem = Poem(poem_title=poem_title, objectid=str(uuid4()), author_id=authors_session.query(Author).filter_by( objectid=author.objectid).first().id) poem_session.add(poem) poem_session.commit() firstQuatrain = FirstQuatrain( objectid=str(uuid4()), quatrain=first_quatrain, poem_title_id=poem_session.query(Poem).filter_by( objectid=poem.objectid).first().id) firstQuantrain_session.add(firstQuatrain) firstQuantrain_session.commit() for part in second_quatrain: secondQuatrain = SecondQuatrain( objectid=str(uuid4()), parts=part.strip(), order_number=(second_quatrain.index(part) + 1), first_quatrain_id=firstQuantrain_session.query( FirstQuatrain).filter_by( objectid=firstQuatrain.objectid).first().id) second_parts_list_object.append(secondQuatrain) random.shuffle(second_parts_list_object) secondQuantrain_session.add_all(second_parts_list_object) secondQuantrain_session.commit() # Создаем лишние записи в таблице авторов и названий стихов fake_author = Author(first_name='Ватрушкин', second_name='Иосиф') authors_session.add(fake_author) authors_session.commit() fake_title = Poem(poem_title='Лишнее название', objectid=str(uuid4())) poem_session.add(fake_title) poem_session.commit() # Закрываем сессии authors_session.close() poem_session.close() firstQuantrain_session.close() secondQuantrain_session.close() # Создаем файл для хранения списка пользователей + prettyTable file_users_path = os.path.join(current_directory, 'users.txt') file = open(file_users_path, 'w', encoding="utf-8") # Создаем и добавляем пользователей сервера. Записываем пользователей в файл for i in range(30): user = User() # engine = connector.get_engine() # engine.execute(get_sql_create_login(user)) random.shuffle(authors_list) p_table = PrettyTable() p_table.field_names = ['Login', 'Password', 'Author name'] print() p_table.add_row([user.username, user.password, authors_list.pop()]) file.write(p_table.get_string()) file.write('\n')
def get_all_results(label: str = None): results = Result.fromListDict(fs_get_all(_collection)) if label is not None: results = [r for r in results if r.config[0]['label'] == label] return results