def test_getToken(self): reader = ConfigReader() resultTest = reader.getToken() data = open('config.json') jdata = json.load(data) resultCorrect = jdata["token"] self.assertEqual(resultTest, resultCorrect)
def test_camAvaible(self): reader = ConfigReader() resultTest = reader.camAvaible() data = open('config.json') jdata = json.load(data) resultCorrect = jdata["avaible"] self.assertEqual(resultTest, resultCorrect)
def allocate(): try: allocatingStatus = ConfigReader.getValue('allocation', 'allocatingStatus') assignlimit = ConfigReader.getIntValue('db', 'assignCount') agents = getAgents() if (len(agents) == 0): print 'No valid Agents found: ' + filterAgentsQuery return for agent in agents: print '' print 'agent - ' + str(agent) agentId = agent[0] rem = (getRemCountForAgent(agentId, assignlimit, allocatingStatus)) if (rem > 0): print 'rem - ' + str(rem) # In case no rows affected, we can check if there are any welcome calls remaining, else stop. setRemWelCalToAgent(agentId, rem, allocatingStatus) else: print 'No more assignment required for agent:' + str(agent) except Exception as e: print 'Exception while allocating' raise e finally: pass return # allocate()
def test_getMotionPin2(self): reader = ConfigReader() resultTest = reader.getMotionPin2() data = open('config.json') jdata = json.load(data) resultCorrect = jdata["motion2"] self.assertEqual(resultTest, resultCorrect)
def test_getHashPass(self): reader = ConfigReader() resultTest = reader.getHashPass() data = open('config.json') jdata = json.load(data) resultCorrect = jdata["passhash"] self.assertEqual(resultTest, resultCorrect)
def test_getNumberOfLED(self): reader = ConfigReader() resultTest = reader.getNumberOfLED() data = open('config.json') jdata = json.load(data) resultCorrect = jdata["number"] self.assertEqual(resultTest, resultCorrect)
def test_api_with_salt_value(self): host_web_app = ConfigReader.read_web_application_host() port_web_app = int(ConfigReader.read_web_application_port()) if host_web_app == "local": start_url = f"{ConfigReader.read_web_application_protocol()}{get_local_ip.get_ip()}:{port_web_app}" else: start_url = f"{ConfigReader.read_web_application_protocol()}{host_web_app}:{port_web_app}" response_salt_value_json = get(start_url + '/api/addRandomSalt/qwe').json() self.assertEqual('salt' in response_salt_value_json, True) self.assertEqual('salt_value' in response_salt_value_json, True) response_with_salt_json = get(start_url + '/api/addSalt', json={ 'value': 'qwe', 'salt': response_salt_value_json["salt"] }).json() self.assertEqual('salt' in response_with_salt_json, True) self.assertEqual('salt_value' in response_with_salt_json, True) self.assertEqual( response_with_salt_json['salt'] == response_salt_value_json['salt'], True) self.assertEqual( response_with_salt_json['salt_value'] == response_salt_value_json['salt_value'], True)
def process(): config = ConfigReader() config.read_config() #read the configuration file ap = AudioProcessor(config.fullfilename) file_list = get_files() # print config.audio_dir # print file_list # f = open('output.txt','a') th_list = [10, 15, 20, 25, 30] th_list = [15] for th in th_list: for file in file_list: filename = config.audio_dir + file print 'start processing: ' + str(file) ap.set_filename(filename) fs = ap.get_samplerate() segment_length, segmentsetidx, pichset, genderset, segment_sample_set = ap.pitchbased_preprocessing( config) sc = SpeakerCounter(fs, segment_length, segmentsetidx, pichset, genderset, segment_sample_set) sc.set_threshold(th) count = sc.get_people_count() # out ="# people in ("+str(file)+") :: "+str(count)+'\n' ac = 4 erc = abs(ac - count) print[str(file), str(count), str(ac), str(erc), str(th)]
def motionLight(self, direction): # Alle LEDs werden eingeschaltet und nach # bestimmten Zeitraum 'period' wieder ausgeschaltet reader = ConfigReader() period = reader.getValue("timeperiod") self.fadeAllIn(direction) time.sleep(float(period)) self.fadeAllOut(direction)
def navigate_to_admin(self,username, password): if Conf.read_ini_config('Paths','HomeURL') in self.driver.current_url: self.driver.find_element(*AdminBase.admin_button).click() elif Conf.read_ini_config('Paths','AdminURL') not in self.driver.current_url: if self.driver.find_element(*LoginLogoutPage.login_link).text == 'Log in': LoginLogoutPage.login_with_valid_credentials(self,username,password) self.driver.get(Conf.read_ini_config('Paths','HomeURL')) self.driver.find_element(*AdminBase.admin_button).click()
def __init__(self): reader = ConfigReader() tokenlist = reader.getValue("token") global token token = [] # Alle Tokens werden aus der Liste geladen for i in tokenlist: token.append(i['t'])
def mountFTP(self): reader = ConfigReader() host = reader.getValue("ftp_host") user = reader.getValue("ftp_user") password = reader.getValue("ftp_pw") path = reader.getValue("ftp_directory") script = 'sh ./script/mountFTP.sh ' arguments = script + " " + path + " " + host + " " + user + " " + password + " " + currentuser subprocess.Popen([arguments], shell=True)
def test_api_random_salt_non_value(self): host_web_app = ConfigReader.read_web_application_host() port_web_app = int(ConfigReader.read_web_application_port()) if host_web_app == "local": start_url = f"{ConfigReader.read_web_application_protocol()}{get_local_ip.get_ip()}:{port_web_app}" else: start_url = f"{ConfigReader.read_web_application_protocol()}{host_web_app}:{port_web_app}" response_json = get(start_url + '/api/addRandomSalt/') self.assertEqual(response_json.status_code == 404, True)
def start_server(host, port): app.register_blueprint(db_api.blueprint) api.add_resource(user_resources.UserListResource, ConfigReader.read_users_api_url()) api.add_resource(user_resources.UserResource, ConfigReader.read_user_api_url()) api.add_resource(bin_user_resources.BinUserResource, ConfigReader.read_get_bin_user_api_url()) DataBase.global_init("bd/name.bd") # UserController.UserController().create_test_user() # app.run(port=8080, host='127.0.0.1') # func_start() app.run(port=port, host=host)
def initStripe(self): # Neopixel Objekt erzeugen # LED_COUNT aus config holen reader = ConfigReader() LED_COUNT = int(reader.getValue("ledcount")) LED_PIN = int(reader.getValue("ledport")) global strip strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT) strip.begin() self.clear()
def login_with_valid_credentials(self, username, password): if Conf.read_ini_config('Paths','AdminURL') in self.driver.current_url: self.driver.get(Conf.read_ini_config('Paths','HomeURL')) if self.driver.find_element(*LoginLogoutPage.login_link).text == 'Log in': self.driver.find_element(*LoginLogoutPage.login_link).click() self.driver.find_element(*LoginLogoutPage.username).clear() self.driver.find_element(*LoginLogoutPage.username).send_keys(username) self.driver.find_element(*LoginLogoutPage.password).clear() self.driver.find_element(*LoginLogoutPage.password).send_keys(password) self.driver.find_element(*LoginLogoutPage.login_button).click() return self.driver.find_element(*LoginLogoutPage.login_link).text
def startRecording(self): path = '/home/'+currentuser+'/ftp' dirAvaible = os.path.exists(path) if dirAvaible: reader = ConfigReader() script = 'sh ./script/recordIpCam.sh ' user = reader.getValue("cam_user") pw = reader.getValue("cam_pw") ip = reader.getValue("cam_host") arguments = script + " " + path + " " + ip + " " + user + " " + pw subprocess.Popen([arguments], shell=True)
def safeImage(self): reader = ConfigReader() user = reader.getValue("cam_user") pw = reader.getValue("cam_pw") ip = reader.getValue("cam_host") camdir = reader.getValue("cam_dir") url = "http://" + user + ":" + pw + "@" + ip + camdir r = requests.get(url) i = Image.open(StringIO(r.content)) path = '/home/'+currentuser+'/ftp/safe/' dirAvaible = os.path.exists(path) if dirAvaible: i.save(path + str(time.time()) + ".jpg")
def get_user(email: str, user_id=None): try: if user_id: return get(_ip_db + ConfigReader.read_user_api_url(), json={ 'id': user_id }).json() else: return get(_ip_db + ConfigReader.read_user_api_url(), json={ 'email': email, }).json() except requests.exceptions.ConnectionError as e: raise ConnectionError
def run(self): # Use BCM GPIO references # instead of physical pin numbers GPIO.setmode(GPIO.BCM) reader = ConfigReader() # Festlegen der beiden Detection-Pins MOTION_PIN1 = int(reader.getValue("motionport1")) MOTION_PIN2 = int(reader.getValue("motionport2")) # Diese als Input definieren GPIO.setup(MOTION_PIN1,GPIO.IN) GPIO.setup(MOTION_PIN2,GPIO.IN) # Status definieren um verschiedene Änderungen zu erkennen Current_State_1 = 0 Previous_State_1 = 0 Current_State_2 = 0 Previous_State_2 = 0 center.writeLog('Motion Detection Status: OK') # Loop zur Erkennung einer Bewegung # Sensort erkennt Bewegung -> Signal = High # Wartet 3 Sekunden und setzt Signal = Low # Die LEDs werden nach bestimmter Zeit wieder # ausgeschaltet. Dies passiert in der Led-Klasse while cond : # Aktuellen Status der Sensoren einlesen Current_State_1 = GPIO.input(MOTION_PIN1) Current_State_2 = GPIO.input(MOTION_PIN2) if (Current_State_1 == 1 and Previous_State_1 == 0 and Current_State_2 == 0): # Sensor 1 hat ausgelöst Previous_State_1 = 1 center.motionDetected(0) if (Current_State_2 == 1 and Previous_State_2 == 0 and Current_State_1 == 0): # Sensor 2 hat ausgelöst Previous_State_2 = 1 center.motionDetected(1) if (Current_State_1 == 0 and Previous_State_1 == 1): # Sensor 1 war an und ist wieder aus Previous_State_1 = 0 if (Current_State_2 == 0 and Previous_State_2 == 1): # Sensor 2 war an und ist wieder aus Previous_State_2 = 0 time.sleep(0.01)
def Register_with_valid_input(self,email, nickname, password, firstname, surname, company, capacity, dateofbirth, phone, mobile,address, zipcode, town, country, how_do_you_know_our_website): self.driver.get(Conf.read_ini_config('Paths','RegisterURL')) self.driver.find_element(*RegistrationPage.Email).send_keys(email) self.driver.find_element(*RegistrationPage.Nickname).send_keys(nickname) self.driver.find_element(*RegistrationPage.Password).send_keys(password) self.driver.find_element(*RegistrationPage.FirstName).send_keys(firstname) self.driver.find_element(*RegistrationPage.Surname).send_keys(surname) self.driver.find_element(*RegistrationPage.Company).send_keys(company) self.driver.find_element(*RegistrationPage.Phone).send_keys(phone) self.driver.find_element(*RegistrationPage.Mobile).send_keys(mobile) self.driver.find_element(*RegistrationPage.Address).send_keys(address) self.driver.find_element(*RegistrationPage.Zipcode).send_keys(zipcode) self.driver.find_element(*RegistrationPage.Phone).send_keys(phone) self.driver.find_element(*RegistrationPage.Town).send_keys(town) self.driver.find_element(*RegistrationPage.Title).click() self.driver.find_element(*RegistrationPage.Capacity).send_keys(capacity) self.driver.find_element(*RegistrationPage.DateOfBirth).send_keys(dateofbirth) self.driver.find_element(*RegistrationPage.Country).send_keys(country) self.driver.find_element(*RegistrationPage.How_do_you_know_our_website).send_keys(how_do_you_know_our_website) self.driver.find_element(*RegistrationPage.Code).send_keys('12340') self.driver.find_element(*RegistrationPage.FirstSelection).click() self.driver.find_element(*RegistrationPage.SecondSelection).click() self.driver.find_element(*RegistrationPage.OpenAccount).click() alert =self.driver.find_element(*RegistrationPage.Thanks_Msg).text LoginLogoutPage.logout(self) return alert
def __init__(self, target='127.0.0.1', message='JOIN'): self._loop = asyncio.get_event_loop() self._config_reader = ConfigReader.ConfigReader() self._port = self._config_reader.get_config_section("Service")['port'] self._target = target self._message = message self._co_routine = None
def __init__(self, globalq): config = ConfigReader.ConfigReader('./main.cfg') locallisten = config.getbykey('ip', 'main'), int( config.getbykey('port', 'main')) self.__server = ThreadedTCPStreamServer(locallisten, ThreadedTCPStreamHandler, queue=globalq)
def FollowOrder(self): self.driver.get(Conf.read_ini_config('Paths','HomeURL')) self.driver.find_element(*FollowUpOrdersPage.FollowUp_Orders_Lnk).click() self.driver.implicitly_wait(10) status =self.driver.find_element(*FollowUpOrdersPage.PaymentStatus_Lnk).text self.driver.find_element(*FollowUpOrdersPage.PaymentStatus_Lnk).click() return status
def getMultipleStatusQryStr(): mulStatus = ConfigReader.getValue('allocation', 'welCalStatusToPick').split(',') qry = '' for status in mulStatus: qry = qry + ' status=' + status + ' or' qry = qry[:-3] return qry
def delete_user(user_id): try: return delete(_ip_db + ConfigReader.read_users_api_url(), json={ 'id': user_id }).json() except requests.exceptions.ConnectionError as e: raise ConnectionError
def check_email(email: str): try: return get(_ip_db + ConfigReader.read_check_email_api_url(), json={ 'email': email }).json() except requests.exceptions.ConnectionError as e: raise ConnectionError
def __init__(self,dbname=None): self.__cfg=cr.readValues('conf.ini','mongo') client = MongoClient(self.__cfg["host"], int(self.__cfg["port"])) if dbname==None: self.db = client[self.__cfg["dbname"]] else: self.db=client[dbname] self.db.authenticate(self.__cfg["user"], self.__cfg["password"])
def check_id(user_id: int): try: return get(_ip_db + ConfigReader.read_check_id_api_url(), json={ 'id': user_id }).json() except requests.exceptions.ConnectionError as e: raise ConnectionError
def getAgents(): role = ConfigReader.getValue('db', 'role') # bima_customer, bima_user_role_permission. filterAgentsQuery = 'SELECT user_id, role_id FROM bima_user_role_permission WHERE user_id > 0 and role_id = ' + role # print filterAgentsQuery validAgents = DBUtils.executeSelectQuery(filterAgentsQuery) return validAgents
def add_salt_value(value: str, salt: str): try: return get(_ip_app + ConfigReader.read_add_salt_value_api_url(), json={ 'value': value, "salt": salt }).json() except requests.exceptions.ConnectionError as e: raise ConnectionError
def __init__(self, newClientCallback=None, dataReceivedCallback=None): self._config_reader = ConfigReader.ConfigReader() self._address = "localhost" self._port = self._config_reader.get_config_section("Service")['port'] self._clients = dict() self._newClientCallback = newClientCallback self._dataReceivedCallback = dataReceivedCallback self._loop = asyncio.get_event_loop() self._server = None
def changing_user_properties(user_id: int, change_properties: dict): try: return post(_ip_db + ConfigReader.read_user_api_url(), json={ 'id': user_id, 'change_properties': change_properties }).json() except requests.exceptions.ConnectionError as e: raise ConnectionError
def __init__(self, remote, func, dictdata): self.__config = ConfigReader.ConfigReader('./main.cfg') self.__remotehost = remote self.__connectiontimeout = int( self.__config.getbykey('timeout', 'heartbeat')) self.__retry = int(self.__config.getbykey('retry', 'heartbeat')) self.__port = int(self.__config.getbykey('port', 'main')) self.targetfunc = func self.__data = dictdata
def __init__(self): Tk.__init__(self) self.wm_title("Tekken Bot Prime") self.iconbitmap('TekkenData/tekken_bot_close.ico') self.color_scheme_config = ConfigReader.ConfigReader("color_scheme") self.color_scheme_config.add_comment("colors with names -> http://www.science.smith.edu/dftwiki/images/3/3d/TkInterColorCharts.png") self.changed_color_scheme("Current", False) self.menu = Menu(self) self.configure(menu=self.menu) self.text = Text(self, wrap="word") sys.stdout = TextRedirector(self.text, "stdout") try: with open("TekkenData/tekken_bot_readme.txt") as fr: lines = fr.readlines() for line in lines: print(line) except: print("Error reading readme file.") self.overlay = fdo.GUI_FrameDataOverlay(self) self.checkbox_dict = {} self.column_menu = Menu(self.menu) for i, enum in enumerate(fdo.DataColumns): bool = self.overlay.redirector.columns_to_print[i] self.add_checkbox(self.column_menu, enum, enum.name, bool, self.changed_columns) self.menu.add_cascade(label='Columns', menu=self.column_menu) self.display_menu = Menu(self.menu) for enum in fdo.DisplaySettings: default = self.overlay.tekken_config.get_property(fdo.DisplaySettings.config_name(), enum.name, False) self.add_checkbox(self.display_menu, enum, enum.name, default, self.changed_display) self.menu.add_cascade(label="Display", menu=self.display_menu) self.color_scheme_menu = Menu(self.menu) self.radio_var = StringVar() for section in self.color_scheme_config.parser.sections(): if section not in ("Comments", "Current"): self.color_scheme_menu.add_radiobutton(label=section, variable=self.radio_var, value=section, command=lambda : self.changed_color_scheme(self.radio_var.get())) self.menu.add_cascade(label="Color Scheme", menu=self.color_scheme_menu) self.text.grid(row = 2, column = 0, columnspan=2, sticky=N+S+E+W) #self.grid_rowconfigure(0, weight=1) self.grid_rowconfigure(2, weight=1) self.grid_columnconfigure(0, weight=1) #self.grid_columnconfigure(1, weight=1) self.geometry(str(720) + 'x' + str(720)) self.overlay.update_launcher() self.overlay.hide()
def __init__(self): self.cfg = ConfigReader.GetConfig() if self.cfg['geo']['enabled'] == True: location = self.GetLocation() self.Longitude = location[1] self.Latitude = location[0] else: self.Longitude = self.cfg['geo']['default_longitude'] self.Latitude = self.cfg['geo']['default_latitude']
def send_confirmation_email(redirection, recipients): try: return post(_ip_app + ConfigReader.read_send_confirmation_email_api_url(), json={ 'redirection': redirection, "recipients": recipients }) except requests.exceptions.ConnectionError as e: raise ConnectionError
def __init__(self, server_address='localhost'): self._config_reader = ConfigReader.ConfigReader() self._port = 26541 # self._config_reader.get_config_section("Service")['port'] # Create a TCP/IP socket self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Connect the socket to the port where the server is listening self._server_address = server_address self._server = (server_address, self._port) logger.info('connecting to %s on port %s' % self._server + '\n')
def advanced_settings(): if request.method == 'GET': cfg = ConfigReader.GetConfig() strip = cfg['strip'] geo = cfg['geo'] return render_template("advanced.html", strip=strip, geo=geo) else: cfg = ConfigReader.GetConfig() strip = cfg['strip'] geo = cfg['geo'] strip['count'] = int(request.form.get('ledCount')) strip['pin'] = int(request.form.get('pinNum')) geo['enabled'] = bool(request.form.get('geoEnabled')) geo['api_key'] = str(request.form.get('apiKey')) geo['location'] = str(request.form.get('location')) geo['default_latitude'] = float(request.form.get('lat')) geo['default_longitude'] = float(request.form.get('lon')) cfg = ConfigReader.Dump(cfg) return redirect('index')
def update_settings(): cfg = ConfigReader.GetConfig() cfg['strip']['brightness'] = int(request.form['brightness']) cfg['strip']['less_than_time'] = request.form['onTime'] cfg['strip']['greater_than_time'] = request.form['endTime'] rgbaVal = request.form['activeColor'] cleanVal = re.sub(r'^.*\(', "", rgbaVal) processedVal = re.sub(r'\)', "", cleanVal).split(',') cfg['strip']['active_color']['R'] = int(processedVal[0]) cfg['strip']['active_color']['G'] = int(processedVal[1]) cfg['strip']['active_color']['B'] = int(processedVal[2]) cfg['start_animation'] = request.form['startAnimation'] cfg['end_animation'] = request.form['endAnimation'] cfg['onTime'] = int(request.form['onDuration']) cfg = ConfigReader.Dump(cfg) return redirect(url_for('index'))
def __init__(self, newClientCallback=None, dataReceivedCallback=None): self._config_reader = ConfigReader.ConfigReader() self._port = int( self._config_reader.get_config_section("Service")['port']) self._clients = dict() self._newClientCallback = newClientCallback self._dataReceivedCallback = dataReceivedCallback self._server = socketserver.ThreadingTCPServer( ('', self._port), ClusterRequestHandler(self._newClientCallback, self._dataReceivedCallback))
def __init__(self): self.stage = 1 config_reader = ConfigReader.ReadConfig() config = config_reader.read() if config.has_section('api_config'): api_config = dict(config.items('api_config', {})) self.request_handler = RequestHandler.RequestHandler(api_config) self.play_game() else: print 'API config not available. Cannot start the game ...'
def connect(self): """ Connect to MySQL database """ db_config = ConfigReader.read_db_config() self.conn = None try: self.conn = mysql.connector.MySQLConnection(**db_config) if self.conn.is_connected(): print('Connected to MySQL database') except Error as e: print(e)
def __init__(self): # Parameters for the connection asyncore.dispatcher.__init__(self) # Overload the previous definition self.config = ConfigReader.ReadConf('bot.conf') # Get the configuration self.create_socket(socket.AF_INET, socket.SOCK_STREAM) # Create the sock_stream socket self.connect((self.config.get("realmadress", "127.0.0.1"), 3724)) # Connect to the realm_server self.buffer = '' # Init the data to send buffer self.packethandler = { # Dictionnary with received opcode and function to call 0x00 : self.SS_AUTH_LOGON_CHALLENGE, 0x01 : self.SS_AUTH_LOGON_PROOF, 0x10 : self.SS_REALM_LIST, 0xFF : self.SS_UNKNOWN, }
def __init__(self): """Initializes class NetworkMapper. If a list of member IPs is found in the config, these are used. Otherwise the network will be scanned. """ self._config_reader = ConfigReader.ConfigReader() ip_list = self._config_reader.get_config_section( "Cluster")['members'].replace(" ", "").split(',') if ip_list[0] == "": self._host_list = self.scan_network() else: self._host_list = self.fill_host_list(ip_list)
def index(): cfg = ConfigReader.GetConfig() strip = cfg['strip'] animation_list = cfg['animations'] start_animation = cfg['start_animation'] end_animation = cfg['end_animation'] onDuration = cfg['onTime'] return render_template("index.html", strip=strip, animation_list=animation_list, start_animation=start_animation, end_animation=end_animation, onDuration=onDuration)
def process_queries(self, cfg_file_name='pc.cfg'): logging.info("Execution begin") configs = ConfigReader.read_cfg(cfg_file_name) logging.info("Configuration file read") begin = time.perf_counter() for xml_file_name in configs['LEIA']: xml_file = minidom.parse(xml_file_name) query_list = xml_file.getElementsByTagName('QUERY') for query in query_list: self._process_xml_query(query) end = time.perf_counter() elapsed = end - begin logging.info("Queries processed: " + str(len(self.expected_docs_by_query)) + " queries read from " + str(len(configs['LEIA'])) + " file(s)") logging.info("Query processor performance: " + str(len(self.expected_docs_by_query)/elapsed) + " queries per second.") self.write_queries(configs['CONSULTAS'][0], configs['ESPERADOS'][0]) logging.info("Query processing saved") logging.info("Execution ended")
def do_index(self, cfg_file="index.cfg"): logging.info("Execution begin") cfg = ConfigReader.read_cfg(cfg_file) logging.info("Configuration file read") inv_list_file = cfg['LEIA'][0] model_file = cfg['ESCREVA'][0] inv_list = self.read_inv_list(inv_list_file) logging.info("Inverted list read: " + str(len(inv_list)) + " terms") self.weight_function.generate_model(inv_list) logging.info("Model generated") with open(model_file, 'wb') as pick_file: pickle.dump(self.weight_function, pick_file) logging.info("Model saved") logging.info("Execution ended")
def do_search(self, config_file_name="busca.cfg"): logging.info("Execution begin") cfg = ConfigReader.read_cfg(config_file_name) logging.info("Configuration file read") model_file_name = cfg["MODELO"][0] queries_file_name = cfg["CONSULTAS"][0] results_file_name = cfg["RESULTADOS"][0] self.model = pickle.load(open(model_file_name, 'rb')) logging.info("Model loaded") queries = dict() with open(queries_file_name) as queries_file: for l in queries_file.readlines(): temp = l.split(';') query_id = temp[0] query = temp[1] queries[query_id] = query n_queries = len(queries) logging.info("Queries file loaded: " + str(n_queries) + " loaded") query_results = dict() begin_time = time.perf_counter() for query_id in queries: similarities = self.model.retrieve(queries[query_id]) query_results[query_id] = similarities end_time = time.perf_counter() elapsed_time = end_time - begin_time logging.info("Retrieval done") logging.info("Retrieval performance: " + str(n_queries/elapsed_time) + " queries per seconds") with open(results_file_name, 'w') as results_file: for query_id in query_results: self._write(query_id, query_results[query_id], results_file) logging.info("Queries results saved") logging.info("Execution ended")
def parse_corpus(self, cfg_file): logging.info("Execution begin") configs = ConfigReader.read_cfg(cfg_file) logging.info("Configuration file read") corpus = dict() for in_file in configs["LEIA"]: document = self.read_xml(in_file) corpus.update(document) logging.info("Corpus read: " + str(len(corpus)) + " documents readed from " + str(len(configs["LEIA"])) + " files") begin = time.perf_counter() inv_list = self.generate_inverted_list(corpus) end = time.perf_counter() elapsed = end - begin logging.info("Inverted list generated: " + str(len(inv_list)) + " terms collected") logging.info("Inverted list performance: " + str(len(corpus)/elapsed) + " documents per second") self.write_inverted_list(inv_list, configs["ESCREVE"][0]) logging.info("Inverted list saved") logging.info("Execution ended")
def getPictureList(self): files = [] reader = ConfigReader() if (reader.camAvaible() == "0"): return files ftphost = reader.getFTP() ftpdirectory = reader.getFTPDirectory() user = reader.getFTPUser() pw = reader.getFTPPW() ftp = ftplib.FTP(ftphost) try: if user == "" && pw == "": # Anonymous Login ftp.login() else: ftp.login(user,pw) except: return files ftp.cwd(ftpdirectory) files = ftp.nlst() ftp.quit() return files
def navigate_to_page(self,username, password): if Conf.read_ini_config('Paths','AdminURL') in self.driver.current_url: self.driver.get(Conf.read_ini_config('Paths','HomeURL')) if self.driver.find_element(*LoginLogoutPage.login_link).text == 'Log in': LoginLogoutPage.login_with_valid_credentials(self,username,password)
def test_camURL_MUST_FAIL(self): reader = ConfigReader() resultTest = reader.camURL() # Muss fehlschlagen!!! resultCorrect = '123' #config.get("cam","adress") self.assertEqual(resultTest, resultCorrect)
def setUpClass(cls): cls.driver = webdriver.Firefox() cls.driver.implicitly_wait(30) cls.driver.maximize_window() # navigate to the application home page cls.driver.get(Conf.read_ini_config('Paths','LoginURL'))
def modifyConfigs(request): if request.method == 'POST': new_url = str(request.POST['url']) ConfigReader.setConfig('URL', new_url) return HttpResponseRedirect("/")
def configs(request): url = ConfigReader.getConfig('URL') default_url = ConfigReader.getConfig('DefaultURL') return render_to_response('configs.html', {'url': url, 'default_url': default_url})
def getServerURL(): serverURL = ConfigReader.getConfig("URL") return serverURL
import ConfigReader # specify eBay API dev,app,cert IDs devID = ConfigReader.getConfig("Developer") appID = ConfigReader.getConfig("Application") certID = ConfigReader.getConfig("Certificate") #get the server details from the config file serverDirectory = ConfigReader.getConfig("Directory") def buildHttpHeaders(): httpHeaders = {'X-EBAY-SOA-OPERATION-NAME': 'findItemsByKeywords',\ 'X-EBAY-SOA-SERVICE-VERSION': '1.3.0', 'X-EBAY-SOA-REQUEST-DATA-FORMAT': 'XML', 'X-EBAY-SOA-GLOBAL-ID': 'EBAY-US', 'X-EBAY-SOA-SECURITY-APPNAME': appID, 'Content-Type': 'text/xml;charset=utf-8'} return httpHeaders def buildRequestXml(keyword): requestXml = "<?xml version='1.0' encoding='utf-8'?>" + \ "<findItemsByKeywordsRequest " + \ "xmlns=\"http://www.ebay.com/marketplace/search/v1/services\">" +\ "<keywords>" + keyword + "</keywords>" + \ "<paginationInput>" + \ "<entriesPerPage>15</entriesPerPage>" + \ "</paginationInput>" + \ "</findItemsByKeywordsRequest>"
# -*- coding: UTF-8 -*- import Functions, ConfigReader import os, sys, time, commands from Client import Client #1.校验tar包MD5码 client = ConfigReader.getClient(sys.argv[1]) tarFileMD5 = Functions.getFileMd5(Client.tarFilePath) if Client.MD5==tarFileMD5: #2.校验成功后解压 Functions.extract(Client.tarFilePath, Client.tempDirPath) #3.停止tomcat服务 (shutresult, shutreturn) = commands.getstatusoutput(Client.tomcatPath+"/bin/shutdown.sh") print("shutresult-------->"+str(shutresult)) # print("shutreturn-------->"+shutreturn) (status, pid) = commands.getstatusoutput("pidof java") if(status == 0): Functions.killProcess() #4.替换程序 print("文件夹路径:"+Client.folderPath) (cpresutl, cpreturn) = commands.getstatusoutput("cp -rf "+Client.folderPath+" "+Client.tomcatPath+"/webapps") print("cpresutl-------->" + str(cpresutl)) #5.删除临时文件 (rmresult, rmreturn) = commands.getstatusoutput("rm -rf "+Client.tempDirPath) print("rmresult-------->" + str(rmresult)) #6.启动tomcat服务